From 7c2cd2f838351599796dc8a52f059d40173a4751 Mon Sep 17 00:00:00 2001 From: MisterRaindrop <278811821@qq.com> Date: Mon, 15 Jun 2026 16:22:27 +0800 Subject: [PATCH 1/2] build(hive): vendor Hive Metastore IDL and pre-generated bindings Generate the Hive Metastore C++ bindings once from the vendored Thrift IDL and check them into src/iceberg/catalog/hive/gen-cpp/, so a normal build needs no Thrift IDL compiler. dev/update_hive_thrift.sh regenerates them when the IDL changes (mirrors Arrow's build-support/update-thrift.sh). The vendored IDL is pinned to Hive 4.0.1: Hive 3.1 declares Table.creationMetadata before CreationMetadata is defined, so Thrift's C++ generator emits an incomplete type that fails under C++23 -Werror; 4.0 reorders the structs. The generated sources keep Thrift's own @generated header instead of an ASF license header, and are excluded from license-eye and the formatting hooks, matching how Apache Arrow vendors its Thrift-generated Parquet code. --- .github/.licenserc.yaml | 1 + .pre-commit-config.yaml | 4 + dev/update_hive_thrift.sh | 45 + .../catalog/hive/gen-cpp/FacebookService.cpp | 4476 + .../catalog/hive/gen-cpp/FacebookService.h | 1673 + .../hive/gen-cpp/ThriftHiveMetastore.cpp | 126865 +++++++++++++++ .../hive/gen-cpp/ThriftHiveMetastore.h | 35369 ++++ .../catalog/hive/gen-cpp/fb303_types.cpp | 53 + .../catalog/hive/gen-cpp/fb303_types.h | 46 + .../hive/gen-cpp/hive_metastore_constants.cpp | 105 + .../hive/gen-cpp/hive_metastore_constants.h | 68 + .../hive/gen-cpp/hive_metastore_types.cpp | 62322 +++++++ .../hive/gen-cpp/hive_metastore_types.h | 15912 ++ thirdparty/hive_metastore/README.md | 2 +- .../hive_metastore/hive_metastore.thrift | 1381 +- 15 files changed, 248183 insertions(+), 139 deletions(-) create mode 100755 dev/update_hive_thrift.sh create mode 100644 src/iceberg/catalog/hive/gen-cpp/FacebookService.cpp create mode 100644 src/iceberg/catalog/hive/gen-cpp/FacebookService.h create mode 100644 src/iceberg/catalog/hive/gen-cpp/ThriftHiveMetastore.cpp create mode 100644 src/iceberg/catalog/hive/gen-cpp/ThriftHiveMetastore.h create mode 100644 src/iceberg/catalog/hive/gen-cpp/fb303_types.cpp create mode 100644 src/iceberg/catalog/hive/gen-cpp/fb303_types.h create mode 100644 src/iceberg/catalog/hive/gen-cpp/hive_metastore_constants.cpp create mode 100644 src/iceberg/catalog/hive/gen-cpp/hive_metastore_constants.h create mode 100644 src/iceberg/catalog/hive/gen-cpp/hive_metastore_types.cpp create mode 100644 src/iceberg/catalog/hive/gen-cpp/hive_metastore_types.h diff --git a/.github/.licenserc.yaml b/.github/.licenserc.yaml index aeaa2f556..a667c903e 100644 --- a/.github/.licenserc.yaml +++ b/.github/.licenserc.yaml @@ -31,6 +31,7 @@ header: - 'requirements.txt' - 'src/iceberg/util/murmurhash3_internal.*' - 'src/iceberg/test/resources/**' + - 'src/iceberg/catalog/hive/gen-cpp/**' - 'thirdparty/**' comment: on-failure diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 7a10bbb63..522923a47 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -25,15 +25,19 @@ repos: rev: v5.0.0 hooks: - id: trailing-whitespace + exclude: ^src/iceberg/catalog/hive/gen-cpp/ - id: end-of-file-fixer + exclude: ^src/iceberg/catalog/hive/gen-cpp/ - id: check-yaml - id: check-added-large-files + exclude: ^src/iceberg/catalog/hive/gen-cpp/ - repo: https://github.com/pre-commit/mirrors-clang-format rev: v20.1.8 hooks: - id: clang-format exclude_types: [json] + exclude: ^src/iceberg/catalog/hive/gen-cpp/ - repo: https://github.com/cheshirekow/cmake-format-precommit rev: v0.6.10 diff --git a/dev/update_hive_thrift.sh b/dev/update_hive_thrift.sh new file mode 100755 index 000000000..3bc7e09d9 --- /dev/null +++ b/dev/update_hive_thrift.sh @@ -0,0 +1,45 @@ +#!/usr/bin/env bash +# +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +# +# Regenerate the committed Hive Metastore C++ bindings from the vendored +# Thrift IDL. Run this whenever thirdparty/hive_metastore/*.thrift changes. +# Requires the Apache Thrift IDL compiler ("thrift") on PATH; the generated +# sources are checked in so a normal build needs no Thrift compiler. + +set -euo pipefail + +repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" +idl_dir="${repo_root}/thirdparty/hive_metastore" +out_dir="${repo_root}/src/iceberg/catalog/hive/gen-cpp" + +if ! command -v thrift >/dev/null 2>&1; then + echo "error: 'thrift' IDL compiler not found on PATH" >&2 + echo " install it (e.g. 'brew install thrift' or 'apt install thrift-compiler')" >&2 + exit 1 +fi + +rm -rf "${out_dir}" +mkdir -p "${out_dir}" + +# -r recurses into included IDL (fb303); cpp:no_skeleton omits server stubs. +thrift -r --gen cpp:no_skeleton -out "${out_dir}" \ + -I "${idl_dir}" "${idl_dir}/hive_metastore.thrift" + +echo "Regenerated Hive Metastore bindings in ${out_dir}" +echo "Review the diff and commit the result." diff --git a/src/iceberg/catalog/hive/gen-cpp/FacebookService.cpp b/src/iceberg/catalog/hive/gen-cpp/FacebookService.cpp new file mode 100644 index 000000000..6db1b83cf --- /dev/null +++ b/src/iceberg/catalog/hive/gen-cpp/FacebookService.cpp @@ -0,0 +1,4476 @@ +/** + * Autogenerated by Thrift Compiler (0.23.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "FacebookService.h" + +namespace facebook { namespace fb303 { + + +FacebookService_getName_args::~FacebookService_getName_args() noexcept { +} + +FacebookService_getName_args::FacebookService_getName_args() noexcept { +} + +uint32_t FacebookService_getName_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_getName_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_getName_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getName_pargs::~FacebookService_getName_pargs() noexcept { +} + + +uint32_t FacebookService_getName_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_getName_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getName_result::~FacebookService_getName_result() noexcept { +} + +FacebookService_getName_result::FacebookService_getName_result() noexcept + : success() { +} + +uint32_t FacebookService_getName_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_getName_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("FacebookService_getName_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0); + xfer += oprot->writeString(this->success); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getName_presult::~FacebookService_getName_presult() noexcept { +} + + +uint32_t FacebookService_getName_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +FacebookService_getVersion_args::~FacebookService_getVersion_args() noexcept { +} + +FacebookService_getVersion_args::FacebookService_getVersion_args() noexcept { +} + +uint32_t FacebookService_getVersion_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_getVersion_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_getVersion_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getVersion_pargs::~FacebookService_getVersion_pargs() noexcept { +} + + +uint32_t FacebookService_getVersion_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_getVersion_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getVersion_result::~FacebookService_getVersion_result() noexcept { +} + +FacebookService_getVersion_result::FacebookService_getVersion_result() noexcept + : success() { +} + +uint32_t FacebookService_getVersion_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_getVersion_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("FacebookService_getVersion_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0); + xfer += oprot->writeString(this->success); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getVersion_presult::~FacebookService_getVersion_presult() noexcept { +} + + +uint32_t FacebookService_getVersion_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +FacebookService_getStatus_args::~FacebookService_getStatus_args() noexcept { +} + +FacebookService_getStatus_args::FacebookService_getStatus_args() noexcept { +} + +uint32_t FacebookService_getStatus_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_getStatus_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_getStatus_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getStatus_pargs::~FacebookService_getStatus_pargs() noexcept { +} + + +uint32_t FacebookService_getStatus_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_getStatus_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getStatus_result::~FacebookService_getStatus_result() noexcept { +} + +FacebookService_getStatus_result::FacebookService_getStatus_result() noexcept + : success(static_cast(0)) { +} + +uint32_t FacebookService_getStatus_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast0; + xfer += iprot->readI32(ecast0); + this->success = static_cast(ecast0); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_getStatus_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("FacebookService_getStatus_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0); + xfer += oprot->writeI32(static_cast(this->success)); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getStatus_presult::~FacebookService_getStatus_presult() noexcept { +} + + +uint32_t FacebookService_getStatus_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1; + xfer += iprot->readI32(ecast1); + (*(this->success)) = static_cast(ecast1); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +FacebookService_getStatusDetails_args::~FacebookService_getStatusDetails_args() noexcept { +} + +FacebookService_getStatusDetails_args::FacebookService_getStatusDetails_args() noexcept { +} + +uint32_t FacebookService_getStatusDetails_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_getStatusDetails_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_getStatusDetails_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getStatusDetails_pargs::~FacebookService_getStatusDetails_pargs() noexcept { +} + + +uint32_t FacebookService_getStatusDetails_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_getStatusDetails_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getStatusDetails_result::~FacebookService_getStatusDetails_result() noexcept { +} + +FacebookService_getStatusDetails_result::FacebookService_getStatusDetails_result() noexcept + : success() { +} + +uint32_t FacebookService_getStatusDetails_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_getStatusDetails_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("FacebookService_getStatusDetails_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0); + xfer += oprot->writeString(this->success); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getStatusDetails_presult::~FacebookService_getStatusDetails_presult() noexcept { +} + + +uint32_t FacebookService_getStatusDetails_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +FacebookService_getCounters_args::~FacebookService_getCounters_args() noexcept { +} + +FacebookService_getCounters_args::FacebookService_getCounters_args() noexcept { +} + +uint32_t FacebookService_getCounters_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_getCounters_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_getCounters_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getCounters_pargs::~FacebookService_getCounters_pargs() noexcept { +} + + +uint32_t FacebookService_getCounters_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_getCounters_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getCounters_result::~FacebookService_getCounters_result() noexcept { +} + +FacebookService_getCounters_result::FacebookService_getCounters_result() noexcept { +} + +uint32_t FacebookService_getCounters_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->success.clear(); + uint32_t _size2; + ::apache::thrift::protocol::TType _ktype3; + ::apache::thrift::protocol::TType _vtype4; + xfer += iprot->readMapBegin(_ktype3, _vtype4, _size2); + uint32_t _i6; + for (_i6 = 0; _i6 < _size2; ++_i6) + { + std::string _key7; + xfer += iprot->readString(_key7); + int64_t& _val8 = this->success[_key7]; + xfer += iprot->readI64(_val8); + } + xfer += iprot->readMapEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_getCounters_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("FacebookService_getCounters_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I64, static_cast(this->success.size())); + std::map ::const_iterator _iter9; + for (_iter9 = this->success.begin(); _iter9 != this->success.end(); ++_iter9) + { + xfer += oprot->writeString(_iter9->first); + xfer += oprot->writeI64(_iter9->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getCounters_presult::~FacebookService_getCounters_presult() noexcept { +} + + +uint32_t FacebookService_getCounters_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + (*(this->success)).clear(); + uint32_t _size10; + ::apache::thrift::protocol::TType _ktype11; + ::apache::thrift::protocol::TType _vtype12; + xfer += iprot->readMapBegin(_ktype11, _vtype12, _size10); + uint32_t _i14; + for (_i14 = 0; _i14 < _size10; ++_i14) + { + std::string _key15; + xfer += iprot->readString(_key15); + int64_t& _val16 = (*(this->success))[_key15]; + xfer += iprot->readI64(_val16); + } + xfer += iprot->readMapEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +FacebookService_getCounter_args::~FacebookService_getCounter_args() noexcept { +} + +FacebookService_getCounter_args::FacebookService_getCounter_args() noexcept + : key() { +} + +uint32_t FacebookService_getCounter_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->key); + this->__isset.key = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_getCounter_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_getCounter_args"); + + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->key); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getCounter_pargs::~FacebookService_getCounter_pargs() noexcept { +} + + +uint32_t FacebookService_getCounter_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_getCounter_pargs"); + + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->key))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getCounter_result::~FacebookService_getCounter_result() noexcept { +} + +FacebookService_getCounter_result::FacebookService_getCounter_result() noexcept + : success(0) { +} + +uint32_t FacebookService_getCounter_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_getCounter_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("FacebookService_getCounter_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I64, 0); + xfer += oprot->writeI64(this->success); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getCounter_presult::~FacebookService_getCounter_presult() noexcept { +} + + +uint32_t FacebookService_getCounter_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +FacebookService_setOption_args::~FacebookService_setOption_args() noexcept { +} + +FacebookService_setOption_args::FacebookService_setOption_args() noexcept + : key(), + value() { +} + +uint32_t FacebookService_setOption_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->key); + this->__isset.key = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->value); + this->__isset.value = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_setOption_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_setOption_args"); + + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->key); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->value); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_setOption_pargs::~FacebookService_setOption_pargs() noexcept { +} + + +uint32_t FacebookService_setOption_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_setOption_pargs"); + + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->key))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->value))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_setOption_result::~FacebookService_setOption_result() noexcept { +} + +FacebookService_setOption_result::FacebookService_setOption_result() noexcept { +} + +uint32_t FacebookService_setOption_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_setOption_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("FacebookService_setOption_result"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_setOption_presult::~FacebookService_setOption_presult() noexcept { +} + + +uint32_t FacebookService_setOption_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +FacebookService_getOption_args::~FacebookService_getOption_args() noexcept { +} + +FacebookService_getOption_args::FacebookService_getOption_args() noexcept + : key() { +} + +uint32_t FacebookService_getOption_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->key); + this->__isset.key = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_getOption_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_getOption_args"); + + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->key); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getOption_pargs::~FacebookService_getOption_pargs() noexcept { +} + + +uint32_t FacebookService_getOption_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_getOption_pargs"); + + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->key))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getOption_result::~FacebookService_getOption_result() noexcept { +} + +FacebookService_getOption_result::FacebookService_getOption_result() noexcept + : success() { +} + +uint32_t FacebookService_getOption_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_getOption_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("FacebookService_getOption_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0); + xfer += oprot->writeString(this->success); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getOption_presult::~FacebookService_getOption_presult() noexcept { +} + + +uint32_t FacebookService_getOption_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +FacebookService_getOptions_args::~FacebookService_getOptions_args() noexcept { +} + +FacebookService_getOptions_args::FacebookService_getOptions_args() noexcept { +} + +uint32_t FacebookService_getOptions_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_getOptions_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_getOptions_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getOptions_pargs::~FacebookService_getOptions_pargs() noexcept { +} + + +uint32_t FacebookService_getOptions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_getOptions_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getOptions_result::~FacebookService_getOptions_result() noexcept { +} + +FacebookService_getOptions_result::FacebookService_getOptions_result() noexcept { +} + +uint32_t FacebookService_getOptions_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->success.clear(); + uint32_t _size17; + ::apache::thrift::protocol::TType _ktype18; + ::apache::thrift::protocol::TType _vtype19; + xfer += iprot->readMapBegin(_ktype18, _vtype19, _size17); + uint32_t _i21; + for (_i21 = 0; _i21 < _size17; ++_i21) + { + std::string _key22; + xfer += iprot->readString(_key22); + std::string& _val23 = this->success[_key22]; + xfer += iprot->readString(_val23); + } + xfer += iprot->readMapEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_getOptions_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("FacebookService_getOptions_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::map ::const_iterator _iter24; + for (_iter24 = this->success.begin(); _iter24 != this->success.end(); ++_iter24) + { + xfer += oprot->writeString(_iter24->first); + xfer += oprot->writeString(_iter24->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getOptions_presult::~FacebookService_getOptions_presult() noexcept { +} + + +uint32_t FacebookService_getOptions_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + (*(this->success)).clear(); + uint32_t _size25; + ::apache::thrift::protocol::TType _ktype26; + ::apache::thrift::protocol::TType _vtype27; + xfer += iprot->readMapBegin(_ktype26, _vtype27, _size25); + uint32_t _i29; + for (_i29 = 0; _i29 < _size25; ++_i29) + { + std::string _key30; + xfer += iprot->readString(_key30); + std::string& _val31 = (*(this->success))[_key30]; + xfer += iprot->readString(_val31); + } + xfer += iprot->readMapEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +FacebookService_getCpuProfile_args::~FacebookService_getCpuProfile_args() noexcept { +} + +FacebookService_getCpuProfile_args::FacebookService_getCpuProfile_args() noexcept + : profileDurationInSec(0) { +} + +uint32_t FacebookService_getCpuProfile_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->profileDurationInSec); + this->__isset.profileDurationInSec = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_getCpuProfile_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_getCpuProfile_args"); + + xfer += oprot->writeFieldBegin("profileDurationInSec", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32(this->profileDurationInSec); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getCpuProfile_pargs::~FacebookService_getCpuProfile_pargs() noexcept { +} + + +uint32_t FacebookService_getCpuProfile_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_getCpuProfile_pargs"); + + xfer += oprot->writeFieldBegin("profileDurationInSec", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32((*(this->profileDurationInSec))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getCpuProfile_result::~FacebookService_getCpuProfile_result() noexcept { +} + +FacebookService_getCpuProfile_result::FacebookService_getCpuProfile_result() noexcept + : success() { +} + +uint32_t FacebookService_getCpuProfile_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_getCpuProfile_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("FacebookService_getCpuProfile_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0); + xfer += oprot->writeString(this->success); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_getCpuProfile_presult::~FacebookService_getCpuProfile_presult() noexcept { +} + + +uint32_t FacebookService_getCpuProfile_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +FacebookService_aliveSince_args::~FacebookService_aliveSince_args() noexcept { +} + +FacebookService_aliveSince_args::FacebookService_aliveSince_args() noexcept { +} + +uint32_t FacebookService_aliveSince_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_aliveSince_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_aliveSince_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_aliveSince_pargs::~FacebookService_aliveSince_pargs() noexcept { +} + + +uint32_t FacebookService_aliveSince_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_aliveSince_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_aliveSince_result::~FacebookService_aliveSince_result() noexcept { +} + +FacebookService_aliveSince_result::FacebookService_aliveSince_result() noexcept + : success(0) { +} + +uint32_t FacebookService_aliveSince_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_aliveSince_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("FacebookService_aliveSince_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I64, 0); + xfer += oprot->writeI64(this->success); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_aliveSince_presult::~FacebookService_aliveSince_presult() noexcept { +} + + +uint32_t FacebookService_aliveSince_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +FacebookService_reinitialize_args::~FacebookService_reinitialize_args() noexcept { +} + +FacebookService_reinitialize_args::FacebookService_reinitialize_args() noexcept { +} + +uint32_t FacebookService_reinitialize_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_reinitialize_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_reinitialize_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_reinitialize_pargs::~FacebookService_reinitialize_pargs() noexcept { +} + + +uint32_t FacebookService_reinitialize_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_reinitialize_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_shutdown_args::~FacebookService_shutdown_args() noexcept { +} + +FacebookService_shutdown_args::FacebookService_shutdown_args() noexcept { +} + +uint32_t FacebookService_shutdown_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FacebookService_shutdown_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_shutdown_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +FacebookService_shutdown_pargs::~FacebookService_shutdown_pargs() noexcept { +} + + +uint32_t FacebookService_shutdown_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FacebookService_shutdown_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void FacebookServiceClient::getName(std::string& _return) +{ + send_getName(); + recv_getName(_return); +} + +void FacebookServiceClient::send_getName() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("getName", ::apache::thrift::protocol::T_CALL, cseqid); + + FacebookService_getName_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void FacebookServiceClient::recv_getName(std::string& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getName") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + FacebookService_getName_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getName failed: unknown result"); +} + +void FacebookServiceClient::getVersion(std::string& _return) +{ + send_getVersion(); + recv_getVersion(_return); +} + +void FacebookServiceClient::send_getVersion() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("getVersion", ::apache::thrift::protocol::T_CALL, cseqid); + + FacebookService_getVersion_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void FacebookServiceClient::recv_getVersion(std::string& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getVersion") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + FacebookService_getVersion_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getVersion failed: unknown result"); +} + +fb_status::type FacebookServiceClient::getStatus() +{ + send_getStatus(); + return recv_getStatus(); +} + +void FacebookServiceClient::send_getStatus() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("getStatus", ::apache::thrift::protocol::T_CALL, cseqid); + + FacebookService_getStatus_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +fb_status::type FacebookServiceClient::recv_getStatus() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getStatus") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + fb_status::type _return; + FacebookService_getStatus_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getStatus failed: unknown result"); +} + +void FacebookServiceClient::getStatusDetails(std::string& _return) +{ + send_getStatusDetails(); + recv_getStatusDetails(_return); +} + +void FacebookServiceClient::send_getStatusDetails() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("getStatusDetails", ::apache::thrift::protocol::T_CALL, cseqid); + + FacebookService_getStatusDetails_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void FacebookServiceClient::recv_getStatusDetails(std::string& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getStatusDetails") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + FacebookService_getStatusDetails_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getStatusDetails failed: unknown result"); +} + +void FacebookServiceClient::getCounters(std::map & _return) +{ + send_getCounters(); + recv_getCounters(_return); +} + +void FacebookServiceClient::send_getCounters() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("getCounters", ::apache::thrift::protocol::T_CALL, cseqid); + + FacebookService_getCounters_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void FacebookServiceClient::recv_getCounters(std::map & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getCounters") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + FacebookService_getCounters_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getCounters failed: unknown result"); +} + +int64_t FacebookServiceClient::getCounter(const std::string& key) +{ + send_getCounter(key); + return recv_getCounter(); +} + +void FacebookServiceClient::send_getCounter(const std::string& key) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("getCounter", ::apache::thrift::protocol::T_CALL, cseqid); + + FacebookService_getCounter_pargs args; + args.key = &key; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +int64_t FacebookServiceClient::recv_getCounter() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getCounter") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + int64_t _return; + FacebookService_getCounter_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getCounter failed: unknown result"); +} + +void FacebookServiceClient::setOption(const std::string& key, const std::string& value) +{ + send_setOption(key, value); + recv_setOption(); +} + +void FacebookServiceClient::send_setOption(const std::string& key, const std::string& value) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("setOption", ::apache::thrift::protocol::T_CALL, cseqid); + + FacebookService_setOption_pargs args; + args.key = &key; + args.value = &value; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void FacebookServiceClient::recv_setOption() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("setOption") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + FacebookService_setOption_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + return; +} + +void FacebookServiceClient::getOption(std::string& _return, const std::string& key) +{ + send_getOption(key); + recv_getOption(_return); +} + +void FacebookServiceClient::send_getOption(const std::string& key) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("getOption", ::apache::thrift::protocol::T_CALL, cseqid); + + FacebookService_getOption_pargs args; + args.key = &key; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void FacebookServiceClient::recv_getOption(std::string& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getOption") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + FacebookService_getOption_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getOption failed: unknown result"); +} + +void FacebookServiceClient::getOptions(std::map & _return) +{ + send_getOptions(); + recv_getOptions(_return); +} + +void FacebookServiceClient::send_getOptions() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("getOptions", ::apache::thrift::protocol::T_CALL, cseqid); + + FacebookService_getOptions_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void FacebookServiceClient::recv_getOptions(std::map & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getOptions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + FacebookService_getOptions_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getOptions failed: unknown result"); +} + +void FacebookServiceClient::getCpuProfile(std::string& _return, const int32_t profileDurationInSec) +{ + send_getCpuProfile(profileDurationInSec); + recv_getCpuProfile(_return); +} + +void FacebookServiceClient::send_getCpuProfile(const int32_t profileDurationInSec) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("getCpuProfile", ::apache::thrift::protocol::T_CALL, cseqid); + + FacebookService_getCpuProfile_pargs args; + args.profileDurationInSec = &profileDurationInSec; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void FacebookServiceClient::recv_getCpuProfile(std::string& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getCpuProfile") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + FacebookService_getCpuProfile_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getCpuProfile failed: unknown result"); +} + +int64_t FacebookServiceClient::aliveSince() +{ + send_aliveSince(); + return recv_aliveSince(); +} + +void FacebookServiceClient::send_aliveSince() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("aliveSince", ::apache::thrift::protocol::T_CALL, cseqid); + + FacebookService_aliveSince_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +int64_t FacebookServiceClient::recv_aliveSince() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("aliveSince") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + int64_t _return; + FacebookService_aliveSince_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "aliveSince failed: unknown result"); +} + +void FacebookServiceClient::reinitialize() +{ + send_reinitialize(); +} + +void FacebookServiceClient::send_reinitialize() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("reinitialize", ::apache::thrift::protocol::T_ONEWAY, cseqid); + + FacebookService_reinitialize_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void FacebookServiceClient::shutdown() +{ + send_shutdown(); +} + +void FacebookServiceClient::send_shutdown() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("shutdown", ::apache::thrift::protocol::T_ONEWAY, cseqid); + + FacebookService_shutdown_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool FacebookServiceProcessor::dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext) { + ProcessMap::iterator pfn; + pfn = processMap_.find(fname); + if (pfn == processMap_.end()) { + iprot->skip(::apache::thrift::protocol::T_STRUCT); + iprot->readMessageEnd(); + iprot->getTransport()->readEnd(); + ::apache::thrift::TApplicationException x(::apache::thrift::TApplicationException::UNKNOWN_METHOD, "Invalid method name: '"+fname+"'"); + oprot->writeMessageBegin(fname, ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return true; + } + (this->*(pfn->second))(seqid, iprot, oprot, callContext); + return true; +} + +void FacebookServiceProcessor::process_getName(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("FacebookService.getName", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "FacebookService.getName"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "FacebookService.getName"); + } + + FacebookService_getName_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "FacebookService.getName", bytes); + } + + FacebookService_getName_result result; + try { + iface_->getName(result.success); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "FacebookService.getName"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("getName", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "FacebookService.getName"); + } + + oprot->writeMessageBegin("getName", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "FacebookService.getName", bytes); + } +} + +void FacebookServiceProcessor::process_getVersion(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("FacebookService.getVersion", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "FacebookService.getVersion"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "FacebookService.getVersion"); + } + + FacebookService_getVersion_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "FacebookService.getVersion", bytes); + } + + FacebookService_getVersion_result result; + try { + iface_->getVersion(result.success); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "FacebookService.getVersion"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("getVersion", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "FacebookService.getVersion"); + } + + oprot->writeMessageBegin("getVersion", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "FacebookService.getVersion", bytes); + } +} + +void FacebookServiceProcessor::process_getStatus(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("FacebookService.getStatus", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "FacebookService.getStatus"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "FacebookService.getStatus"); + } + + FacebookService_getStatus_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "FacebookService.getStatus", bytes); + } + + FacebookService_getStatus_result result; + try { + result.success = iface_->getStatus(); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "FacebookService.getStatus"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("getStatus", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "FacebookService.getStatus"); + } + + oprot->writeMessageBegin("getStatus", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "FacebookService.getStatus", bytes); + } +} + +void FacebookServiceProcessor::process_getStatusDetails(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("FacebookService.getStatusDetails", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "FacebookService.getStatusDetails"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "FacebookService.getStatusDetails"); + } + + FacebookService_getStatusDetails_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "FacebookService.getStatusDetails", bytes); + } + + FacebookService_getStatusDetails_result result; + try { + iface_->getStatusDetails(result.success); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "FacebookService.getStatusDetails"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("getStatusDetails", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "FacebookService.getStatusDetails"); + } + + oprot->writeMessageBegin("getStatusDetails", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "FacebookService.getStatusDetails", bytes); + } +} + +void FacebookServiceProcessor::process_getCounters(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("FacebookService.getCounters", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "FacebookService.getCounters"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "FacebookService.getCounters"); + } + + FacebookService_getCounters_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "FacebookService.getCounters", bytes); + } + + FacebookService_getCounters_result result; + try { + iface_->getCounters(result.success); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "FacebookService.getCounters"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("getCounters", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "FacebookService.getCounters"); + } + + oprot->writeMessageBegin("getCounters", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "FacebookService.getCounters", bytes); + } +} + +void FacebookServiceProcessor::process_getCounter(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("FacebookService.getCounter", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "FacebookService.getCounter"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "FacebookService.getCounter"); + } + + FacebookService_getCounter_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "FacebookService.getCounter", bytes); + } + + FacebookService_getCounter_result result; + try { + result.success = iface_->getCounter(args.key); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "FacebookService.getCounter"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("getCounter", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "FacebookService.getCounter"); + } + + oprot->writeMessageBegin("getCounter", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "FacebookService.getCounter", bytes); + } +} + +void FacebookServiceProcessor::process_setOption(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("FacebookService.setOption", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "FacebookService.setOption"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "FacebookService.setOption"); + } + + FacebookService_setOption_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "FacebookService.setOption", bytes); + } + + FacebookService_setOption_result result; + try { + iface_->setOption(args.key, args.value); + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "FacebookService.setOption"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("setOption", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "FacebookService.setOption"); + } + + oprot->writeMessageBegin("setOption", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "FacebookService.setOption", bytes); + } +} + +void FacebookServiceProcessor::process_getOption(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("FacebookService.getOption", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "FacebookService.getOption"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "FacebookService.getOption"); + } + + FacebookService_getOption_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "FacebookService.getOption", bytes); + } + + FacebookService_getOption_result result; + try { + iface_->getOption(result.success, args.key); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "FacebookService.getOption"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("getOption", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "FacebookService.getOption"); + } + + oprot->writeMessageBegin("getOption", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "FacebookService.getOption", bytes); + } +} + +void FacebookServiceProcessor::process_getOptions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("FacebookService.getOptions", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "FacebookService.getOptions"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "FacebookService.getOptions"); + } + + FacebookService_getOptions_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "FacebookService.getOptions", bytes); + } + + FacebookService_getOptions_result result; + try { + iface_->getOptions(result.success); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "FacebookService.getOptions"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("getOptions", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "FacebookService.getOptions"); + } + + oprot->writeMessageBegin("getOptions", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "FacebookService.getOptions", bytes); + } +} + +void FacebookServiceProcessor::process_getCpuProfile(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("FacebookService.getCpuProfile", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "FacebookService.getCpuProfile"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "FacebookService.getCpuProfile"); + } + + FacebookService_getCpuProfile_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "FacebookService.getCpuProfile", bytes); + } + + FacebookService_getCpuProfile_result result; + try { + iface_->getCpuProfile(result.success, args.profileDurationInSec); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "FacebookService.getCpuProfile"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("getCpuProfile", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "FacebookService.getCpuProfile"); + } + + oprot->writeMessageBegin("getCpuProfile", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "FacebookService.getCpuProfile", bytes); + } +} + +void FacebookServiceProcessor::process_aliveSince(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("FacebookService.aliveSince", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "FacebookService.aliveSince"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "FacebookService.aliveSince"); + } + + FacebookService_aliveSince_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "FacebookService.aliveSince", bytes); + } + + FacebookService_aliveSince_result result; + try { + result.success = iface_->aliveSince(); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "FacebookService.aliveSince"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("aliveSince", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "FacebookService.aliveSince"); + } + + oprot->writeMessageBegin("aliveSince", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "FacebookService.aliveSince", bytes); + } +} + +void FacebookServiceProcessor::process_reinitialize(int32_t, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol*, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("FacebookService.reinitialize", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "FacebookService.reinitialize"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "FacebookService.reinitialize"); + } + + FacebookService_reinitialize_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "FacebookService.reinitialize", bytes); + } + + try { + iface_->reinitialize(); + } catch (const std::exception&) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "FacebookService.reinitialize"); + } + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->asyncComplete(ctx, "FacebookService.reinitialize"); + } + + return; +} + +void FacebookServiceProcessor::process_shutdown(int32_t, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol*, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("FacebookService.shutdown", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "FacebookService.shutdown"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "FacebookService.shutdown"); + } + + FacebookService_shutdown_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "FacebookService.shutdown", bytes); + } + + try { + iface_->shutdown(); + } catch (const std::exception&) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "FacebookService.shutdown"); + } + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->asyncComplete(ctx, "FacebookService.shutdown"); + } + + return; +} + +::std::shared_ptr< ::apache::thrift::TProcessor > FacebookServiceProcessorFactory::getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) { + ::apache::thrift::ReleaseHandler< FacebookServiceIfFactory > cleanup(handlerFactory_); + ::std::shared_ptr< FacebookServiceIf > handler(handlerFactory_->getHandler(connInfo), cleanup); + ::std::shared_ptr< ::apache::thrift::TProcessor > processor(new FacebookServiceProcessor(handler)); + return processor; +} + +void FacebookServiceConcurrentClient::getName(std::string& _return) +{ + int32_t seqid = send_getName(); + recv_getName(_return, seqid); +} + +int32_t FacebookServiceConcurrentClient::send_getName() +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("getName", ::apache::thrift::protocol::T_CALL, cseqid); + + FacebookService_getName_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void FacebookServiceConcurrentClient::recv_getName(std::string& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getName") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + FacebookService_getName_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getName failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void FacebookServiceConcurrentClient::getVersion(std::string& _return) +{ + int32_t seqid = send_getVersion(); + recv_getVersion(_return, seqid); +} + +int32_t FacebookServiceConcurrentClient::send_getVersion() +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("getVersion", ::apache::thrift::protocol::T_CALL, cseqid); + + FacebookService_getVersion_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void FacebookServiceConcurrentClient::recv_getVersion(std::string& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getVersion") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + FacebookService_getVersion_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getVersion failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +fb_status::type FacebookServiceConcurrentClient::getStatus() +{ + int32_t seqid = send_getStatus(); + return recv_getStatus(seqid); +} + +int32_t FacebookServiceConcurrentClient::send_getStatus() +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("getStatus", ::apache::thrift::protocol::T_CALL, cseqid); + + FacebookService_getStatus_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +fb_status::type FacebookServiceConcurrentClient::recv_getStatus(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getStatus") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + fb_status::type _return; + FacebookService_getStatus_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getStatus failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void FacebookServiceConcurrentClient::getStatusDetails(std::string& _return) +{ + int32_t seqid = send_getStatusDetails(); + recv_getStatusDetails(_return, seqid); +} + +int32_t FacebookServiceConcurrentClient::send_getStatusDetails() +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("getStatusDetails", ::apache::thrift::protocol::T_CALL, cseqid); + + FacebookService_getStatusDetails_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void FacebookServiceConcurrentClient::recv_getStatusDetails(std::string& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getStatusDetails") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + FacebookService_getStatusDetails_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getStatusDetails failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void FacebookServiceConcurrentClient::getCounters(std::map & _return) +{ + int32_t seqid = send_getCounters(); + recv_getCounters(_return, seqid); +} + +int32_t FacebookServiceConcurrentClient::send_getCounters() +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("getCounters", ::apache::thrift::protocol::T_CALL, cseqid); + + FacebookService_getCounters_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void FacebookServiceConcurrentClient::recv_getCounters(std::map & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getCounters") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + FacebookService_getCounters_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getCounters failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +int64_t FacebookServiceConcurrentClient::getCounter(const std::string& key) +{ + int32_t seqid = send_getCounter(key); + return recv_getCounter(seqid); +} + +int32_t FacebookServiceConcurrentClient::send_getCounter(const std::string& key) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("getCounter", ::apache::thrift::protocol::T_CALL, cseqid); + + FacebookService_getCounter_pargs args; + args.key = &key; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +int64_t FacebookServiceConcurrentClient::recv_getCounter(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getCounter") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + int64_t _return; + FacebookService_getCounter_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getCounter failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void FacebookServiceConcurrentClient::setOption(const std::string& key, const std::string& value) +{ + int32_t seqid = send_setOption(key, value); + recv_setOption(seqid); +} + +int32_t FacebookServiceConcurrentClient::send_setOption(const std::string& key, const std::string& value) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("setOption", ::apache::thrift::protocol::T_CALL, cseqid); + + FacebookService_setOption_pargs args; + args.key = &key; + args.value = &value; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void FacebookServiceConcurrentClient::recv_setOption(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("setOption") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + FacebookService_setOption_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void FacebookServiceConcurrentClient::getOption(std::string& _return, const std::string& key) +{ + int32_t seqid = send_getOption(key); + recv_getOption(_return, seqid); +} + +int32_t FacebookServiceConcurrentClient::send_getOption(const std::string& key) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("getOption", ::apache::thrift::protocol::T_CALL, cseqid); + + FacebookService_getOption_pargs args; + args.key = &key; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void FacebookServiceConcurrentClient::recv_getOption(std::string& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getOption") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + FacebookService_getOption_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getOption failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void FacebookServiceConcurrentClient::getOptions(std::map & _return) +{ + int32_t seqid = send_getOptions(); + recv_getOptions(_return, seqid); +} + +int32_t FacebookServiceConcurrentClient::send_getOptions() +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("getOptions", ::apache::thrift::protocol::T_CALL, cseqid); + + FacebookService_getOptions_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void FacebookServiceConcurrentClient::recv_getOptions(std::map & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getOptions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + FacebookService_getOptions_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getOptions failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void FacebookServiceConcurrentClient::getCpuProfile(std::string& _return, const int32_t profileDurationInSec) +{ + int32_t seqid = send_getCpuProfile(profileDurationInSec); + recv_getCpuProfile(_return, seqid); +} + +int32_t FacebookServiceConcurrentClient::send_getCpuProfile(const int32_t profileDurationInSec) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("getCpuProfile", ::apache::thrift::protocol::T_CALL, cseqid); + + FacebookService_getCpuProfile_pargs args; + args.profileDurationInSec = &profileDurationInSec; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void FacebookServiceConcurrentClient::recv_getCpuProfile(std::string& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getCpuProfile") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + FacebookService_getCpuProfile_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getCpuProfile failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +int64_t FacebookServiceConcurrentClient::aliveSince() +{ + int32_t seqid = send_aliveSince(); + return recv_aliveSince(seqid); +} + +int32_t FacebookServiceConcurrentClient::send_aliveSince() +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("aliveSince", ::apache::thrift::protocol::T_CALL, cseqid); + + FacebookService_aliveSince_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +int64_t FacebookServiceConcurrentClient::recv_aliveSince(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("aliveSince") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + int64_t _return; + FacebookService_aliveSince_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "aliveSince failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void FacebookServiceConcurrentClient::reinitialize() +{ + send_reinitialize(); +} + +void FacebookServiceConcurrentClient::send_reinitialize() +{ + int32_t cseqid = 0; + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("reinitialize", ::apache::thrift::protocol::T_ONEWAY, cseqid); + + FacebookService_reinitialize_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); +} + +void FacebookServiceConcurrentClient::shutdown() +{ + send_shutdown(); +} + +void FacebookServiceConcurrentClient::send_shutdown() +{ + int32_t cseqid = 0; + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("shutdown", ::apache::thrift::protocol::T_ONEWAY, cseqid); + + FacebookService_shutdown_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); +} + +}} // namespace + diff --git a/src/iceberg/catalog/hive/gen-cpp/FacebookService.h b/src/iceberg/catalog/hive/gen-cpp/FacebookService.h new file mode 100644 index 000000000..d53c459ac --- /dev/null +++ b/src/iceberg/catalog/hive/gen-cpp/FacebookService.h @@ -0,0 +1,1673 @@ +/** + * Autogenerated by Thrift Compiler (0.23.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef FacebookService_H +#define FacebookService_H + +#include +#include +#include +#include "fb303_types.h" + +namespace facebook { namespace fb303 { + +#ifdef _MSC_VER + #pragma warning( push ) + #pragma warning (disable : 4250 ) //inheriting methods via dominance +#endif + +/** + * Standard base service + */ +class FacebookServiceIf { + public: + virtual ~FacebookServiceIf() {} + + /** + * Returns a descriptive name of the service + */ + virtual void getName(std::string& _return) = 0; + + /** + * Returns the version of the service + */ + virtual void getVersion(std::string& _return) = 0; + + /** + * Gets the status of this service + */ + virtual fb_status::type getStatus() = 0; + + /** + * User friendly description of status, such as why the service is in + * the dead or warning state, or what is being started or stopped. + */ + virtual void getStatusDetails(std::string& _return) = 0; + + /** + * Gets the counters for this service + */ + virtual void getCounters(std::map & _return) = 0; + + /** + * Gets the value of a single counter + * + * @param key + */ + virtual int64_t getCounter(const std::string& key) = 0; + + /** + * Sets an option + * + * @param key + * @param value + */ + virtual void setOption(const std::string& key, const std::string& value) = 0; + + /** + * Gets an option + * + * @param key + */ + virtual void getOption(std::string& _return, const std::string& key) = 0; + + /** + * Gets all options + */ + virtual void getOptions(std::map & _return) = 0; + + /** + * Returns a CPU profile over the given time interval (client and server + * must agree on the profile format). + * + * @param profileDurationInSec + */ + virtual void getCpuProfile(std::string& _return, const int32_t profileDurationInSec) = 0; + + /** + * Returns the unix time that the server has been running since + */ + virtual int64_t aliveSince() = 0; + + /** + * Tell the server to reload its configuration, reopen log files, etc + */ + virtual void reinitialize() = 0; + + /** + * Suggest a shutdown to the server + */ + virtual void shutdown() = 0; +}; + +class FacebookServiceIfFactory { + public: + typedef FacebookServiceIf Handler; + + virtual ~FacebookServiceIfFactory() {} + + virtual FacebookServiceIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0; + virtual void releaseHandler(FacebookServiceIf* /* handler */) = 0; + }; + +class FacebookServiceIfSingletonFactory : virtual public FacebookServiceIfFactory { + public: + FacebookServiceIfSingletonFactory(const ::std::shared_ptr& iface) : iface_(iface) {} + virtual ~FacebookServiceIfSingletonFactory() {} + + virtual FacebookServiceIf* getHandler(const ::apache::thrift::TConnectionInfo&) override { + return iface_.get(); + } + virtual void releaseHandler(FacebookServiceIf* /* handler */) override {} + + protected: + ::std::shared_ptr iface_; +}; + +class FacebookServiceNull : virtual public FacebookServiceIf { + public: + virtual ~FacebookServiceNull() {} + void getName(std::string& /* _return */) override { + return; + } + void getVersion(std::string& /* _return */) override { + return; + } + fb_status::type getStatus() override { + fb_status::type _return = static_cast(0); + return _return; + } + void getStatusDetails(std::string& /* _return */) override { + return; + } + void getCounters(std::map & /* _return */) override { + return; + } + int64_t getCounter(const std::string& /* key */) override { + int64_t _return = 0; + return _return; + } + void setOption(const std::string& /* key */, const std::string& /* value */) override { + return; + } + void getOption(std::string& /* _return */, const std::string& /* key */) override { + return; + } + void getOptions(std::map & /* _return */) override { + return; + } + void getCpuProfile(std::string& /* _return */, const int32_t /* profileDurationInSec */) override { + return; + } + int64_t aliveSince() override { + int64_t _return = 0; + return _return; + } + void reinitialize() override { + return; + } + void shutdown() override { + return; + } +}; + + +class FacebookService_getName_args { + public: + + FacebookService_getName_args(const FacebookService_getName_args&) noexcept; + FacebookService_getName_args& operator=(const FacebookService_getName_args&) noexcept; + FacebookService_getName_args() noexcept; + + virtual ~FacebookService_getName_args() noexcept; + + bool operator == (const FacebookService_getName_args & /* rhs */) const; + bool operator != (const FacebookService_getName_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_getName_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class FacebookService_getName_pargs { + public: + + + virtual ~FacebookService_getName_pargs() noexcept; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _FacebookService_getName_result__isset { + _FacebookService_getName_result__isset() : success(false) {} + bool success :1; +} _FacebookService_getName_result__isset; + +class FacebookService_getName_result { + public: + + FacebookService_getName_result(const FacebookService_getName_result&); + FacebookService_getName_result& operator=(const FacebookService_getName_result&); + FacebookService_getName_result() noexcept; + + virtual ~FacebookService_getName_result() noexcept; + std::string success; + + _FacebookService_getName_result__isset __isset; + + void __set_success(const std::string& val); + + bool operator == (const FacebookService_getName_result & rhs) const; + bool operator != (const FacebookService_getName_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_getName_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _FacebookService_getName_presult__isset { + _FacebookService_getName_presult__isset() : success(false) {} + bool success :1; +} _FacebookService_getName_presult__isset; + +class FacebookService_getName_presult { + public: + + + virtual ~FacebookService_getName_presult() noexcept; + std::string* success; + + _FacebookService_getName_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + + +class FacebookService_getVersion_args { + public: + + FacebookService_getVersion_args(const FacebookService_getVersion_args&) noexcept; + FacebookService_getVersion_args& operator=(const FacebookService_getVersion_args&) noexcept; + FacebookService_getVersion_args() noexcept; + + virtual ~FacebookService_getVersion_args() noexcept; + + bool operator == (const FacebookService_getVersion_args & /* rhs */) const; + bool operator != (const FacebookService_getVersion_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_getVersion_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class FacebookService_getVersion_pargs { + public: + + + virtual ~FacebookService_getVersion_pargs() noexcept; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _FacebookService_getVersion_result__isset { + _FacebookService_getVersion_result__isset() : success(false) {} + bool success :1; +} _FacebookService_getVersion_result__isset; + +class FacebookService_getVersion_result { + public: + + FacebookService_getVersion_result(const FacebookService_getVersion_result&); + FacebookService_getVersion_result& operator=(const FacebookService_getVersion_result&); + FacebookService_getVersion_result() noexcept; + + virtual ~FacebookService_getVersion_result() noexcept; + std::string success; + + _FacebookService_getVersion_result__isset __isset; + + void __set_success(const std::string& val); + + bool operator == (const FacebookService_getVersion_result & rhs) const; + bool operator != (const FacebookService_getVersion_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_getVersion_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _FacebookService_getVersion_presult__isset { + _FacebookService_getVersion_presult__isset() : success(false) {} + bool success :1; +} _FacebookService_getVersion_presult__isset; + +class FacebookService_getVersion_presult { + public: + + + virtual ~FacebookService_getVersion_presult() noexcept; + std::string* success; + + _FacebookService_getVersion_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + + +class FacebookService_getStatus_args { + public: + + FacebookService_getStatus_args(const FacebookService_getStatus_args&) noexcept; + FacebookService_getStatus_args& operator=(const FacebookService_getStatus_args&) noexcept; + FacebookService_getStatus_args() noexcept; + + virtual ~FacebookService_getStatus_args() noexcept; + + bool operator == (const FacebookService_getStatus_args & /* rhs */) const; + bool operator != (const FacebookService_getStatus_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_getStatus_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class FacebookService_getStatus_pargs { + public: + + + virtual ~FacebookService_getStatus_pargs() noexcept; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _FacebookService_getStatus_result__isset { + _FacebookService_getStatus_result__isset() : success(false) {} + bool success :1; +} _FacebookService_getStatus_result__isset; + +class FacebookService_getStatus_result { + public: + + FacebookService_getStatus_result(const FacebookService_getStatus_result&) noexcept; + FacebookService_getStatus_result& operator=(const FacebookService_getStatus_result&) noexcept; + FacebookService_getStatus_result() noexcept; + + virtual ~FacebookService_getStatus_result() noexcept; + /** + * + * @see fb_status + */ + fb_status::type success; + + _FacebookService_getStatus_result__isset __isset; + + void __set_success(const fb_status::type val); + + bool operator == (const FacebookService_getStatus_result & rhs) const; + bool operator != (const FacebookService_getStatus_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_getStatus_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _FacebookService_getStatus_presult__isset { + _FacebookService_getStatus_presult__isset() : success(false) {} + bool success :1; +} _FacebookService_getStatus_presult__isset; + +class FacebookService_getStatus_presult { + public: + + + virtual ~FacebookService_getStatus_presult() noexcept; + /** + * + * @see fb_status + */ + fb_status::type* success; + + _FacebookService_getStatus_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + + +class FacebookService_getStatusDetails_args { + public: + + FacebookService_getStatusDetails_args(const FacebookService_getStatusDetails_args&) noexcept; + FacebookService_getStatusDetails_args& operator=(const FacebookService_getStatusDetails_args&) noexcept; + FacebookService_getStatusDetails_args() noexcept; + + virtual ~FacebookService_getStatusDetails_args() noexcept; + + bool operator == (const FacebookService_getStatusDetails_args & /* rhs */) const; + bool operator != (const FacebookService_getStatusDetails_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_getStatusDetails_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class FacebookService_getStatusDetails_pargs { + public: + + + virtual ~FacebookService_getStatusDetails_pargs() noexcept; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _FacebookService_getStatusDetails_result__isset { + _FacebookService_getStatusDetails_result__isset() : success(false) {} + bool success :1; +} _FacebookService_getStatusDetails_result__isset; + +class FacebookService_getStatusDetails_result { + public: + + FacebookService_getStatusDetails_result(const FacebookService_getStatusDetails_result&); + FacebookService_getStatusDetails_result& operator=(const FacebookService_getStatusDetails_result&); + FacebookService_getStatusDetails_result() noexcept; + + virtual ~FacebookService_getStatusDetails_result() noexcept; + std::string success; + + _FacebookService_getStatusDetails_result__isset __isset; + + void __set_success(const std::string& val); + + bool operator == (const FacebookService_getStatusDetails_result & rhs) const; + bool operator != (const FacebookService_getStatusDetails_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_getStatusDetails_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _FacebookService_getStatusDetails_presult__isset { + _FacebookService_getStatusDetails_presult__isset() : success(false) {} + bool success :1; +} _FacebookService_getStatusDetails_presult__isset; + +class FacebookService_getStatusDetails_presult { + public: + + + virtual ~FacebookService_getStatusDetails_presult() noexcept; + std::string* success; + + _FacebookService_getStatusDetails_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + + +class FacebookService_getCounters_args { + public: + + FacebookService_getCounters_args(const FacebookService_getCounters_args&) noexcept; + FacebookService_getCounters_args& operator=(const FacebookService_getCounters_args&) noexcept; + FacebookService_getCounters_args() noexcept; + + virtual ~FacebookService_getCounters_args() noexcept; + + bool operator == (const FacebookService_getCounters_args & /* rhs */) const; + bool operator != (const FacebookService_getCounters_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_getCounters_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class FacebookService_getCounters_pargs { + public: + + + virtual ~FacebookService_getCounters_pargs() noexcept; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _FacebookService_getCounters_result__isset { + _FacebookService_getCounters_result__isset() : success(false) {} + bool success :1; +} _FacebookService_getCounters_result__isset; + +class FacebookService_getCounters_result { + public: + + FacebookService_getCounters_result(const FacebookService_getCounters_result&); + FacebookService_getCounters_result& operator=(const FacebookService_getCounters_result&); + FacebookService_getCounters_result() noexcept; + + virtual ~FacebookService_getCounters_result() noexcept; + std::map success; + + _FacebookService_getCounters_result__isset __isset; + + void __set_success(const std::map & val); + + bool operator == (const FacebookService_getCounters_result & rhs) const; + bool operator != (const FacebookService_getCounters_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_getCounters_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _FacebookService_getCounters_presult__isset { + _FacebookService_getCounters_presult__isset() : success(false) {} + bool success :1; +} _FacebookService_getCounters_presult__isset; + +class FacebookService_getCounters_presult { + public: + + + virtual ~FacebookService_getCounters_presult() noexcept; + std::map * success; + + _FacebookService_getCounters_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _FacebookService_getCounter_args__isset { + _FacebookService_getCounter_args__isset() : key(false) {} + bool key :1; +} _FacebookService_getCounter_args__isset; + +class FacebookService_getCounter_args { + public: + + FacebookService_getCounter_args(const FacebookService_getCounter_args&); + FacebookService_getCounter_args& operator=(const FacebookService_getCounter_args&); + FacebookService_getCounter_args() noexcept; + + virtual ~FacebookService_getCounter_args() noexcept; + std::string key; + + _FacebookService_getCounter_args__isset __isset; + + void __set_key(const std::string& val); + + bool operator == (const FacebookService_getCounter_args & rhs) const; + bool operator != (const FacebookService_getCounter_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_getCounter_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class FacebookService_getCounter_pargs { + public: + + + virtual ~FacebookService_getCounter_pargs() noexcept; + const std::string* key; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _FacebookService_getCounter_result__isset { + _FacebookService_getCounter_result__isset() : success(false) {} + bool success :1; +} _FacebookService_getCounter_result__isset; + +class FacebookService_getCounter_result { + public: + + FacebookService_getCounter_result(const FacebookService_getCounter_result&) noexcept; + FacebookService_getCounter_result& operator=(const FacebookService_getCounter_result&) noexcept; + FacebookService_getCounter_result() noexcept; + + virtual ~FacebookService_getCounter_result() noexcept; + int64_t success; + + _FacebookService_getCounter_result__isset __isset; + + void __set_success(const int64_t val); + + bool operator == (const FacebookService_getCounter_result & rhs) const; + bool operator != (const FacebookService_getCounter_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_getCounter_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _FacebookService_getCounter_presult__isset { + _FacebookService_getCounter_presult__isset() : success(false) {} + bool success :1; +} _FacebookService_getCounter_presult__isset; + +class FacebookService_getCounter_presult { + public: + + + virtual ~FacebookService_getCounter_presult() noexcept; + int64_t* success; + + _FacebookService_getCounter_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _FacebookService_setOption_args__isset { + _FacebookService_setOption_args__isset() : key(false), value(false) {} + bool key :1; + bool value :1; +} _FacebookService_setOption_args__isset; + +class FacebookService_setOption_args { + public: + + FacebookService_setOption_args(const FacebookService_setOption_args&); + FacebookService_setOption_args& operator=(const FacebookService_setOption_args&); + FacebookService_setOption_args() noexcept; + + virtual ~FacebookService_setOption_args() noexcept; + std::string key; + std::string value; + + _FacebookService_setOption_args__isset __isset; + + void __set_key(const std::string& val); + + void __set_value(const std::string& val); + + bool operator == (const FacebookService_setOption_args & rhs) const; + bool operator != (const FacebookService_setOption_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_setOption_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class FacebookService_setOption_pargs { + public: + + + virtual ~FacebookService_setOption_pargs() noexcept; + const std::string* key; + const std::string* value; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class FacebookService_setOption_result { + public: + + FacebookService_setOption_result(const FacebookService_setOption_result&) noexcept; + FacebookService_setOption_result& operator=(const FacebookService_setOption_result&) noexcept; + FacebookService_setOption_result() noexcept; + + virtual ~FacebookService_setOption_result() noexcept; + + bool operator == (const FacebookService_setOption_result & /* rhs */) const; + bool operator != (const FacebookService_setOption_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_setOption_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class FacebookService_setOption_presult { + public: + + + virtual ~FacebookService_setOption_presult() noexcept; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _FacebookService_getOption_args__isset { + _FacebookService_getOption_args__isset() : key(false) {} + bool key :1; +} _FacebookService_getOption_args__isset; + +class FacebookService_getOption_args { + public: + + FacebookService_getOption_args(const FacebookService_getOption_args&); + FacebookService_getOption_args& operator=(const FacebookService_getOption_args&); + FacebookService_getOption_args() noexcept; + + virtual ~FacebookService_getOption_args() noexcept; + std::string key; + + _FacebookService_getOption_args__isset __isset; + + void __set_key(const std::string& val); + + bool operator == (const FacebookService_getOption_args & rhs) const; + bool operator != (const FacebookService_getOption_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_getOption_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class FacebookService_getOption_pargs { + public: + + + virtual ~FacebookService_getOption_pargs() noexcept; + const std::string* key; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _FacebookService_getOption_result__isset { + _FacebookService_getOption_result__isset() : success(false) {} + bool success :1; +} _FacebookService_getOption_result__isset; + +class FacebookService_getOption_result { + public: + + FacebookService_getOption_result(const FacebookService_getOption_result&); + FacebookService_getOption_result& operator=(const FacebookService_getOption_result&); + FacebookService_getOption_result() noexcept; + + virtual ~FacebookService_getOption_result() noexcept; + std::string success; + + _FacebookService_getOption_result__isset __isset; + + void __set_success(const std::string& val); + + bool operator == (const FacebookService_getOption_result & rhs) const; + bool operator != (const FacebookService_getOption_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_getOption_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _FacebookService_getOption_presult__isset { + _FacebookService_getOption_presult__isset() : success(false) {} + bool success :1; +} _FacebookService_getOption_presult__isset; + +class FacebookService_getOption_presult { + public: + + + virtual ~FacebookService_getOption_presult() noexcept; + std::string* success; + + _FacebookService_getOption_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + + +class FacebookService_getOptions_args { + public: + + FacebookService_getOptions_args(const FacebookService_getOptions_args&) noexcept; + FacebookService_getOptions_args& operator=(const FacebookService_getOptions_args&) noexcept; + FacebookService_getOptions_args() noexcept; + + virtual ~FacebookService_getOptions_args() noexcept; + + bool operator == (const FacebookService_getOptions_args & /* rhs */) const; + bool operator != (const FacebookService_getOptions_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_getOptions_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class FacebookService_getOptions_pargs { + public: + + + virtual ~FacebookService_getOptions_pargs() noexcept; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _FacebookService_getOptions_result__isset { + _FacebookService_getOptions_result__isset() : success(false) {} + bool success :1; +} _FacebookService_getOptions_result__isset; + +class FacebookService_getOptions_result { + public: + + FacebookService_getOptions_result(const FacebookService_getOptions_result&); + FacebookService_getOptions_result& operator=(const FacebookService_getOptions_result&); + FacebookService_getOptions_result() noexcept; + + virtual ~FacebookService_getOptions_result() noexcept; + std::map success; + + _FacebookService_getOptions_result__isset __isset; + + void __set_success(const std::map & val); + + bool operator == (const FacebookService_getOptions_result & rhs) const; + bool operator != (const FacebookService_getOptions_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_getOptions_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _FacebookService_getOptions_presult__isset { + _FacebookService_getOptions_presult__isset() : success(false) {} + bool success :1; +} _FacebookService_getOptions_presult__isset; + +class FacebookService_getOptions_presult { + public: + + + virtual ~FacebookService_getOptions_presult() noexcept; + std::map * success; + + _FacebookService_getOptions_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _FacebookService_getCpuProfile_args__isset { + _FacebookService_getCpuProfile_args__isset() : profileDurationInSec(false) {} + bool profileDurationInSec :1; +} _FacebookService_getCpuProfile_args__isset; + +class FacebookService_getCpuProfile_args { + public: + + FacebookService_getCpuProfile_args(const FacebookService_getCpuProfile_args&) noexcept; + FacebookService_getCpuProfile_args& operator=(const FacebookService_getCpuProfile_args&) noexcept; + FacebookService_getCpuProfile_args() noexcept; + + virtual ~FacebookService_getCpuProfile_args() noexcept; + int32_t profileDurationInSec; + + _FacebookService_getCpuProfile_args__isset __isset; + + void __set_profileDurationInSec(const int32_t val); + + bool operator == (const FacebookService_getCpuProfile_args & rhs) const; + bool operator != (const FacebookService_getCpuProfile_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_getCpuProfile_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class FacebookService_getCpuProfile_pargs { + public: + + + virtual ~FacebookService_getCpuProfile_pargs() noexcept; + const int32_t* profileDurationInSec; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _FacebookService_getCpuProfile_result__isset { + _FacebookService_getCpuProfile_result__isset() : success(false) {} + bool success :1; +} _FacebookService_getCpuProfile_result__isset; + +class FacebookService_getCpuProfile_result { + public: + + FacebookService_getCpuProfile_result(const FacebookService_getCpuProfile_result&); + FacebookService_getCpuProfile_result& operator=(const FacebookService_getCpuProfile_result&); + FacebookService_getCpuProfile_result() noexcept; + + virtual ~FacebookService_getCpuProfile_result() noexcept; + std::string success; + + _FacebookService_getCpuProfile_result__isset __isset; + + void __set_success(const std::string& val); + + bool operator == (const FacebookService_getCpuProfile_result & rhs) const; + bool operator != (const FacebookService_getCpuProfile_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_getCpuProfile_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _FacebookService_getCpuProfile_presult__isset { + _FacebookService_getCpuProfile_presult__isset() : success(false) {} + bool success :1; +} _FacebookService_getCpuProfile_presult__isset; + +class FacebookService_getCpuProfile_presult { + public: + + + virtual ~FacebookService_getCpuProfile_presult() noexcept; + std::string* success; + + _FacebookService_getCpuProfile_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + + +class FacebookService_aliveSince_args { + public: + + FacebookService_aliveSince_args(const FacebookService_aliveSince_args&) noexcept; + FacebookService_aliveSince_args& operator=(const FacebookService_aliveSince_args&) noexcept; + FacebookService_aliveSince_args() noexcept; + + virtual ~FacebookService_aliveSince_args() noexcept; + + bool operator == (const FacebookService_aliveSince_args & /* rhs */) const; + bool operator != (const FacebookService_aliveSince_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_aliveSince_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class FacebookService_aliveSince_pargs { + public: + + + virtual ~FacebookService_aliveSince_pargs() noexcept; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _FacebookService_aliveSince_result__isset { + _FacebookService_aliveSince_result__isset() : success(false) {} + bool success :1; +} _FacebookService_aliveSince_result__isset; + +class FacebookService_aliveSince_result { + public: + + FacebookService_aliveSince_result(const FacebookService_aliveSince_result&) noexcept; + FacebookService_aliveSince_result& operator=(const FacebookService_aliveSince_result&) noexcept; + FacebookService_aliveSince_result() noexcept; + + virtual ~FacebookService_aliveSince_result() noexcept; + int64_t success; + + _FacebookService_aliveSince_result__isset __isset; + + void __set_success(const int64_t val); + + bool operator == (const FacebookService_aliveSince_result & rhs) const; + bool operator != (const FacebookService_aliveSince_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_aliveSince_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _FacebookService_aliveSince_presult__isset { + _FacebookService_aliveSince_presult__isset() : success(false) {} + bool success :1; +} _FacebookService_aliveSince_presult__isset; + +class FacebookService_aliveSince_presult { + public: + + + virtual ~FacebookService_aliveSince_presult() noexcept; + int64_t* success; + + _FacebookService_aliveSince_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + + +class FacebookService_reinitialize_args { + public: + + FacebookService_reinitialize_args(const FacebookService_reinitialize_args&) noexcept; + FacebookService_reinitialize_args& operator=(const FacebookService_reinitialize_args&) noexcept; + FacebookService_reinitialize_args() noexcept; + + virtual ~FacebookService_reinitialize_args() noexcept; + + bool operator == (const FacebookService_reinitialize_args & /* rhs */) const; + bool operator != (const FacebookService_reinitialize_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_reinitialize_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class FacebookService_reinitialize_pargs { + public: + + + virtual ~FacebookService_reinitialize_pargs() noexcept; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class FacebookService_shutdown_args { + public: + + FacebookService_shutdown_args(const FacebookService_shutdown_args&) noexcept; + FacebookService_shutdown_args& operator=(const FacebookService_shutdown_args&) noexcept; + FacebookService_shutdown_args() noexcept; + + virtual ~FacebookService_shutdown_args() noexcept; + + bool operator == (const FacebookService_shutdown_args & /* rhs */) const; + bool operator != (const FacebookService_shutdown_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FacebookService_shutdown_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class FacebookService_shutdown_pargs { + public: + + + virtual ~FacebookService_shutdown_pargs() noexcept; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +class FacebookServiceClient : virtual public FacebookServiceIf { + public: + FacebookServiceClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot); + } + FacebookServiceClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + setProtocol(iprot,oprot); + } + private: + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot,prot); + } + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + piprot_=iprot; + poprot_=oprot; + iprot_ = iprot.get(); + oprot_ = oprot.get(); + } + public: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + /** + * Returns a descriptive name of the service + */ + void getName(std::string& _return) override; + void send_getName(); + void recv_getName(std::string& _return); + /** + * Returns the version of the service + */ + void getVersion(std::string& _return) override; + void send_getVersion(); + void recv_getVersion(std::string& _return); + /** + * Gets the status of this service + */ + fb_status::type getStatus() override; + void send_getStatus(); + fb_status::type recv_getStatus(); + /** + * User friendly description of status, such as why the service is in + * the dead or warning state, or what is being started or stopped. + */ + void getStatusDetails(std::string& _return) override; + void send_getStatusDetails(); + void recv_getStatusDetails(std::string& _return); + /** + * Gets the counters for this service + */ + void getCounters(std::map & _return) override; + void send_getCounters(); + void recv_getCounters(std::map & _return); + /** + * Gets the value of a single counter + * + * @param key + */ + int64_t getCounter(const std::string& key) override; + void send_getCounter(const std::string& key); + int64_t recv_getCounter(); + /** + * Sets an option + * + * @param key + * @param value + */ + void setOption(const std::string& key, const std::string& value) override; + void send_setOption(const std::string& key, const std::string& value); + void recv_setOption(); + /** + * Gets an option + * + * @param key + */ + void getOption(std::string& _return, const std::string& key) override; + void send_getOption(const std::string& key); + void recv_getOption(std::string& _return); + /** + * Gets all options + */ + void getOptions(std::map & _return) override; + void send_getOptions(); + void recv_getOptions(std::map & _return); + /** + * Returns a CPU profile over the given time interval (client and server + * must agree on the profile format). + * + * @param profileDurationInSec + */ + void getCpuProfile(std::string& _return, const int32_t profileDurationInSec) override; + void send_getCpuProfile(const int32_t profileDurationInSec); + void recv_getCpuProfile(std::string& _return); + /** + * Returns the unix time that the server has been running since + */ + int64_t aliveSince() override; + void send_aliveSince(); + int64_t recv_aliveSince(); + /** + * Tell the server to reload its configuration, reopen log files, etc + */ + void reinitialize() override; + void send_reinitialize(); + /** + * Suggest a shutdown to the server + */ + void shutdown() override; + void send_shutdown(); + protected: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_; + std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_; + ::apache::thrift::protocol::TProtocol* iprot_; + ::apache::thrift::protocol::TProtocol* oprot_; +}; + +class FacebookServiceProcessor : public ::apache::thrift::TDispatchProcessor { + protected: + ::std::shared_ptr iface_; + virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext) override; + private: + typedef void (FacebookServiceProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*); + typedef std::map ProcessMap; + ProcessMap processMap_; + void process_getName(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_getVersion(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_getStatus(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_getStatusDetails(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_getCounters(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_getCounter(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_setOption(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_getOption(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_getOptions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_getCpuProfile(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_aliveSince(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_reinitialize(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_shutdown(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + public: + FacebookServiceProcessor(::std::shared_ptr iface) : + iface_(iface) { + processMap_["getName"] = &FacebookServiceProcessor::process_getName; + processMap_["getVersion"] = &FacebookServiceProcessor::process_getVersion; + processMap_["getStatus"] = &FacebookServiceProcessor::process_getStatus; + processMap_["getStatusDetails"] = &FacebookServiceProcessor::process_getStatusDetails; + processMap_["getCounters"] = &FacebookServiceProcessor::process_getCounters; + processMap_["getCounter"] = &FacebookServiceProcessor::process_getCounter; + processMap_["setOption"] = &FacebookServiceProcessor::process_setOption; + processMap_["getOption"] = &FacebookServiceProcessor::process_getOption; + processMap_["getOptions"] = &FacebookServiceProcessor::process_getOptions; + processMap_["getCpuProfile"] = &FacebookServiceProcessor::process_getCpuProfile; + processMap_["aliveSince"] = &FacebookServiceProcessor::process_aliveSince; + processMap_["reinitialize"] = &FacebookServiceProcessor::process_reinitialize; + processMap_["shutdown"] = &FacebookServiceProcessor::process_shutdown; + } + + virtual ~FacebookServiceProcessor() {} +}; + +class FacebookServiceProcessorFactory : public ::apache::thrift::TProcessorFactory { + public: + FacebookServiceProcessorFactory(const ::std::shared_ptr< FacebookServiceIfFactory >& handlerFactory) noexcept : + handlerFactory_(handlerFactory) {} + + ::std::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) override; + + protected: + ::std::shared_ptr< FacebookServiceIfFactory > handlerFactory_; +}; + +class FacebookServiceMultiface : virtual public FacebookServiceIf { + public: + FacebookServiceMultiface(std::vector >& ifaces) : ifaces_(ifaces) { + } + virtual ~FacebookServiceMultiface() {} + protected: + std::vector > ifaces_; + FacebookServiceMultiface() {} + void add(::std::shared_ptr iface) { + ifaces_.push_back(iface); + } + public: + /** + * Returns a descriptive name of the service + */ + void getName(std::string& _return) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->getName(_return); + } + ifaces_[i]->getName(_return); + return; + } + + /** + * Returns the version of the service + */ + void getVersion(std::string& _return) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->getVersion(_return); + } + ifaces_[i]->getVersion(_return); + return; + } + + /** + * Gets the status of this service + */ + fb_status::type getStatus() override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->getStatus(); + } + return ifaces_[i]->getStatus(); + } + + /** + * User friendly description of status, such as why the service is in + * the dead or warning state, or what is being started or stopped. + */ + void getStatusDetails(std::string& _return) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->getStatusDetails(_return); + } + ifaces_[i]->getStatusDetails(_return); + return; + } + + /** + * Gets the counters for this service + */ + void getCounters(std::map & _return) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->getCounters(_return); + } + ifaces_[i]->getCounters(_return); + return; + } + + /** + * Gets the value of a single counter + * + * @param key + */ + int64_t getCounter(const std::string& key) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->getCounter(key); + } + return ifaces_[i]->getCounter(key); + } + + /** + * Sets an option + * + * @param key + * @param value + */ + void setOption(const std::string& key, const std::string& value) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->setOption(key, value); + } + ifaces_[i]->setOption(key, value); + } + + /** + * Gets an option + * + * @param key + */ + void getOption(std::string& _return, const std::string& key) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->getOption(_return, key); + } + ifaces_[i]->getOption(_return, key); + return; + } + + /** + * Gets all options + */ + void getOptions(std::map & _return) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->getOptions(_return); + } + ifaces_[i]->getOptions(_return); + return; + } + + /** + * Returns a CPU profile over the given time interval (client and server + * must agree on the profile format). + * + * @param profileDurationInSec + */ + void getCpuProfile(std::string& _return, const int32_t profileDurationInSec) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->getCpuProfile(_return, profileDurationInSec); + } + ifaces_[i]->getCpuProfile(_return, profileDurationInSec); + return; + } + + /** + * Returns the unix time that the server has been running since + */ + int64_t aliveSince() override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->aliveSince(); + } + return ifaces_[i]->aliveSince(); + } + + /** + * Tell the server to reload its configuration, reopen log files, etc + */ + void reinitialize() override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->reinitialize(); + } + ifaces_[i]->reinitialize(); + } + + /** + * Suggest a shutdown to the server + */ + void shutdown() override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->shutdown(); + } + ifaces_[i]->shutdown(); + } + +}; + +// The 'concurrent' client is a thread safe client that correctly handles +// out of order responses. It is slower than the regular client, so should +// only be used when you need to share a connection among multiple threads +class FacebookServiceConcurrentClient : virtual public FacebookServiceIf { + public: + FacebookServiceConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot, std::shared_ptr< ::apache::thrift::async::TConcurrentClientSyncInfo> sync) : sync_(sync) +{ + setProtocol(prot); + } + FacebookServiceConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot, std::shared_ptr< ::apache::thrift::async::TConcurrentClientSyncInfo> sync) : sync_(sync) +{ + setProtocol(iprot,oprot); + } + private: + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot,prot); + } + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + piprot_=iprot; + poprot_=oprot; + iprot_ = iprot.get(); + oprot_ = oprot.get(); + } + public: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + /** + * Returns a descriptive name of the service + */ + void getName(std::string& _return) override; + int32_t send_getName(); + void recv_getName(std::string& _return, const int32_t seqid); + /** + * Returns the version of the service + */ + void getVersion(std::string& _return) override; + int32_t send_getVersion(); + void recv_getVersion(std::string& _return, const int32_t seqid); + /** + * Gets the status of this service + */ + fb_status::type getStatus() override; + int32_t send_getStatus(); + fb_status::type recv_getStatus(const int32_t seqid); + /** + * User friendly description of status, such as why the service is in + * the dead or warning state, or what is being started or stopped. + */ + void getStatusDetails(std::string& _return) override; + int32_t send_getStatusDetails(); + void recv_getStatusDetails(std::string& _return, const int32_t seqid); + /** + * Gets the counters for this service + */ + void getCounters(std::map & _return) override; + int32_t send_getCounters(); + void recv_getCounters(std::map & _return, const int32_t seqid); + /** + * Gets the value of a single counter + * + * @param key + */ + int64_t getCounter(const std::string& key) override; + int32_t send_getCounter(const std::string& key); + int64_t recv_getCounter(const int32_t seqid); + /** + * Sets an option + * + * @param key + * @param value + */ + void setOption(const std::string& key, const std::string& value) override; + int32_t send_setOption(const std::string& key, const std::string& value); + void recv_setOption(const int32_t seqid); + /** + * Gets an option + * + * @param key + */ + void getOption(std::string& _return, const std::string& key) override; + int32_t send_getOption(const std::string& key); + void recv_getOption(std::string& _return, const int32_t seqid); + /** + * Gets all options + */ + void getOptions(std::map & _return) override; + int32_t send_getOptions(); + void recv_getOptions(std::map & _return, const int32_t seqid); + /** + * Returns a CPU profile over the given time interval (client and server + * must agree on the profile format). + * + * @param profileDurationInSec + */ + void getCpuProfile(std::string& _return, const int32_t profileDurationInSec) override; + int32_t send_getCpuProfile(const int32_t profileDurationInSec); + void recv_getCpuProfile(std::string& _return, const int32_t seqid); + /** + * Returns the unix time that the server has been running since + */ + int64_t aliveSince() override; + int32_t send_aliveSince(); + int64_t recv_aliveSince(const int32_t seqid); + /** + * Tell the server to reload its configuration, reopen log files, etc + */ + void reinitialize() override; + void send_reinitialize(); + /** + * Suggest a shutdown to the server + */ + void shutdown() override; + void send_shutdown(); + protected: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_; + std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_; + ::apache::thrift::protocol::TProtocol* iprot_; + ::apache::thrift::protocol::TProtocol* oprot_; + std::shared_ptr< ::apache::thrift::async::TConcurrentClientSyncInfo> sync_; +}; + +#ifdef _MSC_VER + #pragma warning( pop ) +#endif + +}} // namespace + +#endif diff --git a/src/iceberg/catalog/hive/gen-cpp/ThriftHiveMetastore.cpp b/src/iceberg/catalog/hive/gen-cpp/ThriftHiveMetastore.cpp new file mode 100644 index 000000000..19fa0cf1a --- /dev/null +++ b/src/iceberg/catalog/hive/gen-cpp/ThriftHiveMetastore.cpp @@ -0,0 +1,126865 @@ +/** + * Autogenerated by Thrift Compiler (0.23.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "ThriftHiveMetastore.h" + +namespace Apache { namespace Hadoop { namespace Hive { + + +ThriftHiveMetastore_abort_Compactions_args::~ThriftHiveMetastore_abort_Compactions_args() noexcept { +} + +ThriftHiveMetastore_abort_Compactions_args::ThriftHiveMetastore_abort_Compactions_args() noexcept { +} + +uint32_t ThriftHiveMetastore_abort_Compactions_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_abort_Compactions_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_Compactions_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_abort_Compactions_pargs::~ThriftHiveMetastore_abort_Compactions_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_abort_Compactions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_Compactions_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_abort_Compactions_result::~ThriftHiveMetastore_abort_Compactions_result() noexcept { +} + +ThriftHiveMetastore_abort_Compactions_result::ThriftHiveMetastore_abort_Compactions_result() noexcept { +} + +uint32_t ThriftHiveMetastore_abort_Compactions_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_abort_Compactions_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_Compactions_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_abort_Compactions_presult::~ThriftHiveMetastore_abort_Compactions_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_abort_Compactions_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_getMetaConf_args::~ThriftHiveMetastore_getMetaConf_args() noexcept { +} + +ThriftHiveMetastore_getMetaConf_args::ThriftHiveMetastore_getMetaConf_args() noexcept + : key() { +} + +uint32_t ThriftHiveMetastore_getMetaConf_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->key); + this->__isset.key = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_getMetaConf_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_getMetaConf_args"); + + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->key); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_getMetaConf_pargs::~ThriftHiveMetastore_getMetaConf_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_getMetaConf_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_getMetaConf_pargs"); + + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->key))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_getMetaConf_result::~ThriftHiveMetastore_getMetaConf_result() noexcept { +} + +ThriftHiveMetastore_getMetaConf_result::ThriftHiveMetastore_getMetaConf_result() noexcept + : success() { +} + +uint32_t ThriftHiveMetastore_getMetaConf_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_getMetaConf_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_getMetaConf_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0); + xfer += oprot->writeString(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_getMetaConf_presult::~ThriftHiveMetastore_getMetaConf_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_getMetaConf_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_setMetaConf_args::~ThriftHiveMetastore_setMetaConf_args() noexcept { +} + +ThriftHiveMetastore_setMetaConf_args::ThriftHiveMetastore_setMetaConf_args() noexcept + : key(), + value() { +} + +uint32_t ThriftHiveMetastore_setMetaConf_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->key); + this->__isset.key = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->value); + this->__isset.value = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_setMetaConf_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_setMetaConf_args"); + + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->key); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->value); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_setMetaConf_pargs::~ThriftHiveMetastore_setMetaConf_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_setMetaConf_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_setMetaConf_pargs"); + + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->key))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->value))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_setMetaConf_result::~ThriftHiveMetastore_setMetaConf_result() noexcept { +} + +ThriftHiveMetastore_setMetaConf_result::ThriftHiveMetastore_setMetaConf_result() noexcept { +} + +uint32_t ThriftHiveMetastore_setMetaConf_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_setMetaConf_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_setMetaConf_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_setMetaConf_presult::~ThriftHiveMetastore_setMetaConf_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_setMetaConf_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_create_catalog_args::~ThriftHiveMetastore_create_catalog_args() noexcept { +} + +ThriftHiveMetastore_create_catalog_args::ThriftHiveMetastore_create_catalog_args() noexcept { +} + +uint32_t ThriftHiveMetastore_create_catalog_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->catalog.read(iprot); + this->__isset.catalog = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_catalog_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_catalog_args"); + + xfer += oprot->writeFieldBegin("catalog", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->catalog.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_catalog_pargs::~ThriftHiveMetastore_create_catalog_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_catalog_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_catalog_pargs"); + + xfer += oprot->writeFieldBegin("catalog", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->catalog)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_catalog_result::~ThriftHiveMetastore_create_catalog_result() noexcept { +} + +ThriftHiveMetastore_create_catalog_result::ThriftHiveMetastore_create_catalog_result() noexcept { +} + +uint32_t ThriftHiveMetastore_create_catalog_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_catalog_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_catalog_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_catalog_presult::~ThriftHiveMetastore_create_catalog_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_catalog_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_alter_catalog_args::~ThriftHiveMetastore_alter_catalog_args() noexcept { +} + +ThriftHiveMetastore_alter_catalog_args::ThriftHiveMetastore_alter_catalog_args() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_catalog_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_catalog_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_catalog_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_catalog_pargs::~ThriftHiveMetastore_alter_catalog_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_catalog_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_catalog_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_catalog_result::~ThriftHiveMetastore_alter_catalog_result() noexcept { +} + +ThriftHiveMetastore_alter_catalog_result::ThriftHiveMetastore_alter_catalog_result() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_catalog_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_catalog_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_catalog_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_catalog_presult::~ThriftHiveMetastore_alter_catalog_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_catalog_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_catalog_args::~ThriftHiveMetastore_get_catalog_args() noexcept { +} + +ThriftHiveMetastore_get_catalog_args::ThriftHiveMetastore_get_catalog_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_catalog_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->catName.read(iprot); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_catalog_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_catalog_args"); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->catName.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_catalog_pargs::~ThriftHiveMetastore_get_catalog_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_catalog_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_catalog_pargs"); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->catName)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_catalog_result::~ThriftHiveMetastore_get_catalog_result() noexcept { +} + +ThriftHiveMetastore_get_catalog_result::ThriftHiveMetastore_get_catalog_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_catalog_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_catalog_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_catalog_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_catalog_presult::~ThriftHiveMetastore_get_catalog_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_catalog_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_catalogs_args::~ThriftHiveMetastore_get_catalogs_args() noexcept { +} + +ThriftHiveMetastore_get_catalogs_args::ThriftHiveMetastore_get_catalogs_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_catalogs_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_catalogs_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_catalogs_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_catalogs_pargs::~ThriftHiveMetastore_get_catalogs_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_catalogs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_catalogs_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_catalogs_result::~ThriftHiveMetastore_get_catalogs_result() noexcept { +} + +ThriftHiveMetastore_get_catalogs_result::ThriftHiveMetastore_get_catalogs_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_catalogs_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_catalogs_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_catalogs_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_catalogs_presult::~ThriftHiveMetastore_get_catalogs_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_catalogs_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_catalog_args::~ThriftHiveMetastore_drop_catalog_args() noexcept { +} + +ThriftHiveMetastore_drop_catalog_args::ThriftHiveMetastore_drop_catalog_args() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_catalog_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->catName.read(iprot); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_catalog_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_catalog_args"); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->catName.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_catalog_pargs::~ThriftHiveMetastore_drop_catalog_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_catalog_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_catalog_pargs"); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->catName)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_catalog_result::~ThriftHiveMetastore_drop_catalog_result() noexcept { +} + +ThriftHiveMetastore_drop_catalog_result::ThriftHiveMetastore_drop_catalog_result() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_catalog_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_catalog_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_catalog_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_catalog_presult::~ThriftHiveMetastore_drop_catalog_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_catalog_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_create_database_args::~ThriftHiveMetastore_create_database_args() noexcept { +} + +ThriftHiveMetastore_create_database_args::ThriftHiveMetastore_create_database_args() noexcept { +} + +uint32_t ThriftHiveMetastore_create_database_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->database.read(iprot); + this->__isset.database = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_database_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_database_args"); + + xfer += oprot->writeFieldBegin("database", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->database.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_database_pargs::~ThriftHiveMetastore_create_database_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_database_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_database_pargs"); + + xfer += oprot->writeFieldBegin("database", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->database)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_database_result::~ThriftHiveMetastore_create_database_result() noexcept { +} + +ThriftHiveMetastore_create_database_result::ThriftHiveMetastore_create_database_result() noexcept { +} + +uint32_t ThriftHiveMetastore_create_database_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_database_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_database_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_database_presult::~ThriftHiveMetastore_create_database_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_database_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_create_database_req_args::~ThriftHiveMetastore_create_database_req_args() noexcept { +} + +ThriftHiveMetastore_create_database_req_args::ThriftHiveMetastore_create_database_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_create_database_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->createDatabaseRequest.read(iprot); + this->__isset.createDatabaseRequest = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_database_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_database_req_args"); + + xfer += oprot->writeFieldBegin("createDatabaseRequest", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->createDatabaseRequest.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_database_req_pargs::~ThriftHiveMetastore_create_database_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_database_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_database_req_pargs"); + + xfer += oprot->writeFieldBegin("createDatabaseRequest", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->createDatabaseRequest)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_database_req_result::~ThriftHiveMetastore_create_database_req_result() noexcept { +} + +ThriftHiveMetastore_create_database_req_result::ThriftHiveMetastore_create_database_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_create_database_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_database_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_database_req_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_database_req_presult::~ThriftHiveMetastore_create_database_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_database_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_database_args::~ThriftHiveMetastore_get_database_args() noexcept { +} + +ThriftHiveMetastore_get_database_args::ThriftHiveMetastore_get_database_args() noexcept + : name() { +} + +uint32_t ThriftHiveMetastore_get_database_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_database_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_database_args"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_database_pargs::~ThriftHiveMetastore_get_database_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_database_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_database_pargs"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_database_result::~ThriftHiveMetastore_get_database_result() noexcept { +} + +ThriftHiveMetastore_get_database_result::ThriftHiveMetastore_get_database_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_database_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_database_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_database_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_database_presult::~ThriftHiveMetastore_get_database_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_database_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_database_req_args::~ThriftHiveMetastore_get_database_req_args() noexcept { +} + +ThriftHiveMetastore_get_database_req_args::ThriftHiveMetastore_get_database_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_database_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_database_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_database_req_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_database_req_pargs::~ThriftHiveMetastore_get_database_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_database_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_database_req_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_database_req_result::~ThriftHiveMetastore_get_database_req_result() noexcept { +} + +ThriftHiveMetastore_get_database_req_result::ThriftHiveMetastore_get_database_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_database_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_database_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_database_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_database_req_presult::~ThriftHiveMetastore_get_database_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_database_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_database_args::~ThriftHiveMetastore_drop_database_args() noexcept { +} + +ThriftHiveMetastore_drop_database_args::ThriftHiveMetastore_drop_database_args() noexcept + : name(), + deleteData(0), + cascade(0) { +} + +uint32_t ThriftHiveMetastore_drop_database_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->deleteData); + this->__isset.deleteData = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->cascade); + this->__isset.cascade = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_database_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_database_args"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool(this->deleteData); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("cascade", ::apache::thrift::protocol::T_BOOL, 3); + xfer += oprot->writeBool(this->cascade); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_database_pargs::~ThriftHiveMetastore_drop_database_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_database_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_database_pargs"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool((*(this->deleteData))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("cascade", ::apache::thrift::protocol::T_BOOL, 3); + xfer += oprot->writeBool((*(this->cascade))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_database_result::~ThriftHiveMetastore_drop_database_result() noexcept { +} + +ThriftHiveMetastore_drop_database_result::ThriftHiveMetastore_drop_database_result() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_database_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_database_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_database_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_database_presult::~ThriftHiveMetastore_drop_database_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_database_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_database_req_args::~ThriftHiveMetastore_drop_database_req_args() noexcept { +} + +ThriftHiveMetastore_drop_database_req_args::ThriftHiveMetastore_drop_database_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_database_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_database_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_database_req_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_database_req_pargs::~ThriftHiveMetastore_drop_database_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_database_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_database_req_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_database_req_result::~ThriftHiveMetastore_drop_database_req_result() noexcept { +} + +ThriftHiveMetastore_drop_database_req_result::ThriftHiveMetastore_drop_database_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_database_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_database_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_database_req_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_database_req_presult::~ThriftHiveMetastore_drop_database_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_database_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_databases_args::~ThriftHiveMetastore_get_databases_args() noexcept { +} + +ThriftHiveMetastore_get_databases_args::ThriftHiveMetastore_get_databases_args() noexcept + : pattern() { +} + +uint32_t ThriftHiveMetastore_get_databases_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->pattern); + this->__isset.pattern = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_databases_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_databases_args"); + + xfer += oprot->writeFieldBegin("pattern", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->pattern); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_databases_pargs::~ThriftHiveMetastore_get_databases_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_databases_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_databases_pargs"); + + xfer += oprot->writeFieldBegin("pattern", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->pattern))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_databases_result::~ThriftHiveMetastore_get_databases_result() noexcept { +} + +ThriftHiveMetastore_get_databases_result::ThriftHiveMetastore_get_databases_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_databases_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size1887; + ::apache::thrift::protocol::TType _etype1890; + xfer += iprot->readListBegin(_etype1890, _size1887); + this->success.resize(_size1887); + uint32_t _i1891; + for (_i1891 = 0; _i1891 < _size1887; ++_i1891) + { + xfer += iprot->readString(this->success[_i1891]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_databases_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_databases_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::vector ::const_iterator _iter1892; + for (_iter1892 = this->success.begin(); _iter1892 != this->success.end(); ++_iter1892) + { + xfer += oprot->writeString((*_iter1892)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_databases_presult::~ThriftHiveMetastore_get_databases_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_databases_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size1893; + ::apache::thrift::protocol::TType _etype1896; + xfer += iprot->readListBegin(_etype1896, _size1893); + (*(this->success)).resize(_size1893); + uint32_t _i1897; + for (_i1897 = 0; _i1897 < _size1893; ++_i1897) + { + xfer += iprot->readString((*(this->success))[_i1897]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_all_databases_args::~ThriftHiveMetastore_get_all_databases_args() noexcept { +} + +ThriftHiveMetastore_get_all_databases_args::ThriftHiveMetastore_get_all_databases_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_all_databases_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_all_databases_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_databases_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_databases_pargs::~ThriftHiveMetastore_get_all_databases_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_all_databases_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_databases_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_databases_result::~ThriftHiveMetastore_get_all_databases_result() noexcept { +} + +ThriftHiveMetastore_get_all_databases_result::ThriftHiveMetastore_get_all_databases_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_all_databases_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size1898; + ::apache::thrift::protocol::TType _etype1901; + xfer += iprot->readListBegin(_etype1901, _size1898); + this->success.resize(_size1898); + uint32_t _i1902; + for (_i1902 = 0; _i1902 < _size1898; ++_i1902) + { + xfer += iprot->readString(this->success[_i1902]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_all_databases_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_databases_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::vector ::const_iterator _iter1903; + for (_iter1903 = this->success.begin(); _iter1903 != this->success.end(); ++_iter1903) + { + xfer += oprot->writeString((*_iter1903)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_databases_presult::~ThriftHiveMetastore_get_all_databases_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_all_databases_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size1904; + ::apache::thrift::protocol::TType _etype1907; + xfer += iprot->readListBegin(_etype1907, _size1904); + (*(this->success)).resize(_size1904); + uint32_t _i1908; + for (_i1908 = 0; _i1908 < _size1904; ++_i1908) + { + xfer += iprot->readString((*(this->success))[_i1908]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_alter_database_args::~ThriftHiveMetastore_alter_database_args() noexcept { +} + +ThriftHiveMetastore_alter_database_args::ThriftHiveMetastore_alter_database_args() noexcept + : dbname() { +} + +uint32_t ThriftHiveMetastore_alter_database_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbname); + this->__isset.dbname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->db.read(iprot); + this->__isset.db = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_database_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_database_args"); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbname); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("db", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->db.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_database_pargs::~ThriftHiveMetastore_alter_database_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_database_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_database_pargs"); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->dbname))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("db", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += (*(this->db)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_database_result::~ThriftHiveMetastore_alter_database_result() noexcept { +} + +ThriftHiveMetastore_alter_database_result::ThriftHiveMetastore_alter_database_result() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_database_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_database_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_database_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_database_presult::~ThriftHiveMetastore_alter_database_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_database_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_alter_database_req_args::~ThriftHiveMetastore_alter_database_req_args() noexcept { +} + +ThriftHiveMetastore_alter_database_req_args::ThriftHiveMetastore_alter_database_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_database_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->alterDbReq.read(iprot); + this->__isset.alterDbReq = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_database_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_database_req_args"); + + xfer += oprot->writeFieldBegin("alterDbReq", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->alterDbReq.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_database_req_pargs::~ThriftHiveMetastore_alter_database_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_database_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_database_req_pargs"); + + xfer += oprot->writeFieldBegin("alterDbReq", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->alterDbReq)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_database_req_result::~ThriftHiveMetastore_alter_database_req_result() noexcept { +} + +ThriftHiveMetastore_alter_database_req_result::ThriftHiveMetastore_alter_database_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_database_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_database_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_database_req_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_database_req_presult::~ThriftHiveMetastore_alter_database_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_database_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_create_dataconnector_req_args::~ThriftHiveMetastore_create_dataconnector_req_args() noexcept { +} + +ThriftHiveMetastore_create_dataconnector_req_args::ThriftHiveMetastore_create_dataconnector_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_create_dataconnector_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->connectorReq.read(iprot); + this->__isset.connectorReq = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_dataconnector_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_dataconnector_req_args"); + + xfer += oprot->writeFieldBegin("connectorReq", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->connectorReq.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_dataconnector_req_pargs::~ThriftHiveMetastore_create_dataconnector_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_dataconnector_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_dataconnector_req_pargs"); + + xfer += oprot->writeFieldBegin("connectorReq", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->connectorReq)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_dataconnector_req_result::~ThriftHiveMetastore_create_dataconnector_req_result() noexcept { +} + +ThriftHiveMetastore_create_dataconnector_req_result::ThriftHiveMetastore_create_dataconnector_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_create_dataconnector_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_dataconnector_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_dataconnector_req_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_dataconnector_req_presult::~ThriftHiveMetastore_create_dataconnector_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_dataconnector_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_dataconnector_req_args::~ThriftHiveMetastore_get_dataconnector_req_args() noexcept { +} + +ThriftHiveMetastore_get_dataconnector_req_args::ThriftHiveMetastore_get_dataconnector_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_dataconnector_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_dataconnector_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_dataconnector_req_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_dataconnector_req_pargs::~ThriftHiveMetastore_get_dataconnector_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_dataconnector_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_dataconnector_req_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_dataconnector_req_result::~ThriftHiveMetastore_get_dataconnector_req_result() noexcept { +} + +ThriftHiveMetastore_get_dataconnector_req_result::ThriftHiveMetastore_get_dataconnector_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_dataconnector_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_dataconnector_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_dataconnector_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_dataconnector_req_presult::~ThriftHiveMetastore_get_dataconnector_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_dataconnector_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_dataconnector_req_args::~ThriftHiveMetastore_drop_dataconnector_req_args() noexcept { +} + +ThriftHiveMetastore_drop_dataconnector_req_args::ThriftHiveMetastore_drop_dataconnector_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_dataconnector_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->dropDcReq.read(iprot); + this->__isset.dropDcReq = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_dataconnector_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_dataconnector_req_args"); + + xfer += oprot->writeFieldBegin("dropDcReq", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->dropDcReq.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_dataconnector_req_pargs::~ThriftHiveMetastore_drop_dataconnector_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_dataconnector_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_dataconnector_req_pargs"); + + xfer += oprot->writeFieldBegin("dropDcReq", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->dropDcReq)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_dataconnector_req_result::~ThriftHiveMetastore_drop_dataconnector_req_result() noexcept { +} + +ThriftHiveMetastore_drop_dataconnector_req_result::ThriftHiveMetastore_drop_dataconnector_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_dataconnector_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_dataconnector_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_dataconnector_req_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_dataconnector_req_presult::~ThriftHiveMetastore_drop_dataconnector_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_dataconnector_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_dataconnectors_args::~ThriftHiveMetastore_get_dataconnectors_args() noexcept { +} + +ThriftHiveMetastore_get_dataconnectors_args::ThriftHiveMetastore_get_dataconnectors_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_dataconnectors_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_dataconnectors_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_dataconnectors_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_dataconnectors_pargs::~ThriftHiveMetastore_get_dataconnectors_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_dataconnectors_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_dataconnectors_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_dataconnectors_result::~ThriftHiveMetastore_get_dataconnectors_result() noexcept { +} + +ThriftHiveMetastore_get_dataconnectors_result::ThriftHiveMetastore_get_dataconnectors_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_dataconnectors_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size1909; + ::apache::thrift::protocol::TType _etype1912; + xfer += iprot->readListBegin(_etype1912, _size1909); + this->success.resize(_size1909); + uint32_t _i1913; + for (_i1913 = 0; _i1913 < _size1909; ++_i1913) + { + xfer += iprot->readString(this->success[_i1913]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_dataconnectors_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_dataconnectors_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::vector ::const_iterator _iter1914; + for (_iter1914 = this->success.begin(); _iter1914 != this->success.end(); ++_iter1914) + { + xfer += oprot->writeString((*_iter1914)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_dataconnectors_presult::~ThriftHiveMetastore_get_dataconnectors_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_dataconnectors_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size1915; + ::apache::thrift::protocol::TType _etype1918; + xfer += iprot->readListBegin(_etype1918, _size1915); + (*(this->success)).resize(_size1915); + uint32_t _i1919; + for (_i1919 = 0; _i1919 < _size1915; ++_i1919) + { + xfer += iprot->readString((*(this->success))[_i1919]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_alter_dataconnector_req_args::~ThriftHiveMetastore_alter_dataconnector_req_args() noexcept { +} + +ThriftHiveMetastore_alter_dataconnector_req_args::ThriftHiveMetastore_alter_dataconnector_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_dataconnector_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->alterReq.read(iprot); + this->__isset.alterReq = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_dataconnector_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_dataconnector_req_args"); + + xfer += oprot->writeFieldBegin("alterReq", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->alterReq.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_dataconnector_req_pargs::~ThriftHiveMetastore_alter_dataconnector_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_dataconnector_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_dataconnector_req_pargs"); + + xfer += oprot->writeFieldBegin("alterReq", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->alterReq)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_dataconnector_req_result::~ThriftHiveMetastore_alter_dataconnector_req_result() noexcept { +} + +ThriftHiveMetastore_alter_dataconnector_req_result::ThriftHiveMetastore_alter_dataconnector_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_dataconnector_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_dataconnector_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_dataconnector_req_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_dataconnector_req_presult::~ThriftHiveMetastore_alter_dataconnector_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_dataconnector_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_type_args::~ThriftHiveMetastore_get_type_args() noexcept { +} + +ThriftHiveMetastore_get_type_args::ThriftHiveMetastore_get_type_args() noexcept + : name() { +} + +uint32_t ThriftHiveMetastore_get_type_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_type_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_type_args"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_type_pargs::~ThriftHiveMetastore_get_type_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_type_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_type_pargs"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_type_result::~ThriftHiveMetastore_get_type_result() noexcept { +} + +ThriftHiveMetastore_get_type_result::ThriftHiveMetastore_get_type_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_type_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_type_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_type_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_type_presult::~ThriftHiveMetastore_get_type_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_type_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_create_type_args::~ThriftHiveMetastore_create_type_args() noexcept { +} + +ThriftHiveMetastore_create_type_args::ThriftHiveMetastore_create_type_args() noexcept { +} + +uint32_t ThriftHiveMetastore_create_type_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->type.read(iprot); + this->__isset.type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_type_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_type_args"); + + xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->type.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_type_pargs::~ThriftHiveMetastore_create_type_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_type_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_type_pargs"); + + xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->type)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_type_result::~ThriftHiveMetastore_create_type_result() noexcept { +} + +ThriftHiveMetastore_create_type_result::ThriftHiveMetastore_create_type_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_create_type_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_type_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_type_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_type_presult::~ThriftHiveMetastore_create_type_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_type_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_type_args::~ThriftHiveMetastore_drop_type_args() noexcept { +} + +ThriftHiveMetastore_drop_type_args::ThriftHiveMetastore_drop_type_args() noexcept + : type() { +} + +uint32_t ThriftHiveMetastore_drop_type_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->type); + this->__isset.type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_type_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_type_args"); + + xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->type); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_type_pargs::~ThriftHiveMetastore_drop_type_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_type_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_type_pargs"); + + xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->type))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_type_result::~ThriftHiveMetastore_drop_type_result() noexcept { +} + +ThriftHiveMetastore_drop_type_result::ThriftHiveMetastore_drop_type_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_drop_type_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_type_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_type_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_type_presult::~ThriftHiveMetastore_drop_type_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_type_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_type_all_args::~ThriftHiveMetastore_get_type_all_args() noexcept { +} + +ThriftHiveMetastore_get_type_all_args::ThriftHiveMetastore_get_type_all_args() noexcept + : name() { +} + +uint32_t ThriftHiveMetastore_get_type_all_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_type_all_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_type_all_args"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_type_all_pargs::~ThriftHiveMetastore_get_type_all_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_type_all_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_type_all_pargs"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_type_all_result::~ThriftHiveMetastore_get_type_all_result() noexcept { +} + +ThriftHiveMetastore_get_type_all_result::ThriftHiveMetastore_get_type_all_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_type_all_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->success.clear(); + uint32_t _size1920; + ::apache::thrift::protocol::TType _ktype1921; + ::apache::thrift::protocol::TType _vtype1922; + xfer += iprot->readMapBegin(_ktype1921, _vtype1922, _size1920); + uint32_t _i1924; + for (_i1924 = 0; _i1924 < _size1920; ++_i1924) + { + std::string _key1925; + xfer += iprot->readString(_key1925); + Type& _val1926 = this->success[_key1925]; + xfer += _val1926.read(iprot); + } + xfer += iprot->readMapEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_type_all_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_type_all_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::map ::const_iterator _iter1927; + for (_iter1927 = this->success.begin(); _iter1927 != this->success.end(); ++_iter1927) + { + xfer += oprot->writeString(_iter1927->first); + xfer += _iter1927->second.write(oprot); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_type_all_presult::~ThriftHiveMetastore_get_type_all_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_type_all_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + (*(this->success)).clear(); + uint32_t _size1928; + ::apache::thrift::protocol::TType _ktype1929; + ::apache::thrift::protocol::TType _vtype1930; + xfer += iprot->readMapBegin(_ktype1929, _vtype1930, _size1928); + uint32_t _i1932; + for (_i1932 = 0; _i1932 < _size1928; ++_i1932) + { + std::string _key1933; + xfer += iprot->readString(_key1933); + Type& _val1934 = (*(this->success))[_key1933]; + xfer += _val1934.read(iprot); + } + xfer += iprot->readMapEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_fields_args::~ThriftHiveMetastore_get_fields_args() noexcept { +} + +ThriftHiveMetastore_get_fields_args::ThriftHiveMetastore_get_fields_args() noexcept + : db_name(), + table_name() { +} + +uint32_t ThriftHiveMetastore_get_fields_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->table_name); + this->__isset.table_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_fields_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_fields_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->table_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_fields_pargs::~ThriftHiveMetastore_get_fields_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_fields_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_fields_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->table_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_fields_result::~ThriftHiveMetastore_get_fields_result() noexcept { +} + +ThriftHiveMetastore_get_fields_result::ThriftHiveMetastore_get_fields_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_fields_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size1935; + ::apache::thrift::protocol::TType _etype1938; + xfer += iprot->readListBegin(_etype1938, _size1935); + this->success.resize(_size1935); + uint32_t _i1939; + for (_i1939 = 0; _i1939 < _size1935; ++_i1939) + { + xfer += this->success[_i1939].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_fields_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_fields_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter1940; + for (_iter1940 = this->success.begin(); _iter1940 != this->success.end(); ++_iter1940) + { + xfer += (*_iter1940).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_fields_presult::~ThriftHiveMetastore_get_fields_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_fields_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size1941; + ::apache::thrift::protocol::TType _etype1944; + xfer += iprot->readListBegin(_etype1944, _size1941); + (*(this->success)).resize(_size1941); + uint32_t _i1945; + for (_i1945 = 0; _i1945 < _size1941; ++_i1945) + { + xfer += (*(this->success))[_i1945].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_fields_with_environment_context_args::~ThriftHiveMetastore_get_fields_with_environment_context_args() noexcept { +} + +ThriftHiveMetastore_get_fields_with_environment_context_args::ThriftHiveMetastore_get_fields_with_environment_context_args() noexcept + : db_name(), + table_name() { +} + +uint32_t ThriftHiveMetastore_get_fields_with_environment_context_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->table_name); + this->__isset.table_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->environment_context.read(iprot); + this->__isset.environment_context = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_fields_with_environment_context_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_fields_with_environment_context_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->table_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->environment_context.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_fields_with_environment_context_pargs::~ThriftHiveMetastore_get_fields_with_environment_context_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_fields_with_environment_context_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_fields_with_environment_context_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->table_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += (*(this->environment_context)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_fields_with_environment_context_result::~ThriftHiveMetastore_get_fields_with_environment_context_result() noexcept { +} + +ThriftHiveMetastore_get_fields_with_environment_context_result::ThriftHiveMetastore_get_fields_with_environment_context_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size1946; + ::apache::thrift::protocol::TType _etype1949; + xfer += iprot->readListBegin(_etype1949, _size1946); + this->success.resize(_size1946); + uint32_t _i1950; + for (_i1950 = 0; _i1950 < _size1946; ++_i1950) + { + xfer += this->success[_i1950].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_fields_with_environment_context_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter1951; + for (_iter1951 = this->success.begin(); _iter1951 != this->success.end(); ++_iter1951) + { + xfer += (*_iter1951).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_fields_with_environment_context_presult::~ThriftHiveMetastore_get_fields_with_environment_context_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_fields_with_environment_context_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size1952; + ::apache::thrift::protocol::TType _etype1955; + xfer += iprot->readListBegin(_etype1955, _size1952); + (*(this->success)).resize(_size1952); + uint32_t _i1956; + for (_i1956 = 0; _i1956 < _size1952; ++_i1956) + { + xfer += (*(this->success))[_i1956].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_fields_req_args::~ThriftHiveMetastore_get_fields_req_args() noexcept { +} + +ThriftHiveMetastore_get_fields_req_args::ThriftHiveMetastore_get_fields_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_fields_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_fields_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_fields_req_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_fields_req_pargs::~ThriftHiveMetastore_get_fields_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_fields_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_fields_req_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_fields_req_result::~ThriftHiveMetastore_get_fields_req_result() noexcept { +} + +ThriftHiveMetastore_get_fields_req_result::ThriftHiveMetastore_get_fields_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_fields_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_fields_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_fields_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_fields_req_presult::~ThriftHiveMetastore_get_fields_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_fields_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_schema_args::~ThriftHiveMetastore_get_schema_args() noexcept { +} + +ThriftHiveMetastore_get_schema_args::ThriftHiveMetastore_get_schema_args() noexcept + : db_name(), + table_name() { +} + +uint32_t ThriftHiveMetastore_get_schema_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->table_name); + this->__isset.table_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_schema_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_schema_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->table_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_schema_pargs::~ThriftHiveMetastore_get_schema_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_schema_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_schema_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->table_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_schema_result::~ThriftHiveMetastore_get_schema_result() noexcept { +} + +ThriftHiveMetastore_get_schema_result::ThriftHiveMetastore_get_schema_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_schema_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size1957; + ::apache::thrift::protocol::TType _etype1960; + xfer += iprot->readListBegin(_etype1960, _size1957); + this->success.resize(_size1957); + uint32_t _i1961; + for (_i1961 = 0; _i1961 < _size1957; ++_i1961) + { + xfer += this->success[_i1961].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_schema_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_schema_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter1962; + for (_iter1962 = this->success.begin(); _iter1962 != this->success.end(); ++_iter1962) + { + xfer += (*_iter1962).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_schema_presult::~ThriftHiveMetastore_get_schema_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_schema_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size1963; + ::apache::thrift::protocol::TType _etype1966; + xfer += iprot->readListBegin(_etype1966, _size1963); + (*(this->success)).resize(_size1963); + uint32_t _i1967; + for (_i1967 = 0; _i1967 < _size1963; ++_i1967) + { + xfer += (*(this->success))[_i1967].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_schema_with_environment_context_args::~ThriftHiveMetastore_get_schema_with_environment_context_args() noexcept { +} + +ThriftHiveMetastore_get_schema_with_environment_context_args::ThriftHiveMetastore_get_schema_with_environment_context_args() noexcept + : db_name(), + table_name() { +} + +uint32_t ThriftHiveMetastore_get_schema_with_environment_context_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->table_name); + this->__isset.table_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->environment_context.read(iprot); + this->__isset.environment_context = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_schema_with_environment_context_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_schema_with_environment_context_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->table_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->environment_context.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_schema_with_environment_context_pargs::~ThriftHiveMetastore_get_schema_with_environment_context_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_schema_with_environment_context_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_schema_with_environment_context_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->table_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += (*(this->environment_context)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_schema_with_environment_context_result::~ThriftHiveMetastore_get_schema_with_environment_context_result() noexcept { +} + +ThriftHiveMetastore_get_schema_with_environment_context_result::ThriftHiveMetastore_get_schema_with_environment_context_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size1968; + ::apache::thrift::protocol::TType _etype1971; + xfer += iprot->readListBegin(_etype1971, _size1968); + this->success.resize(_size1968); + uint32_t _i1972; + for (_i1972 = 0; _i1972 < _size1968; ++_i1972) + { + xfer += this->success[_i1972].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_schema_with_environment_context_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter1973; + for (_iter1973 = this->success.begin(); _iter1973 != this->success.end(); ++_iter1973) + { + xfer += (*_iter1973).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_schema_with_environment_context_presult::~ThriftHiveMetastore_get_schema_with_environment_context_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_schema_with_environment_context_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size1974; + ::apache::thrift::protocol::TType _etype1977; + xfer += iprot->readListBegin(_etype1977, _size1974); + (*(this->success)).resize(_size1974); + uint32_t _i1978; + for (_i1978 = 0; _i1978 < _size1974; ++_i1978) + { + xfer += (*(this->success))[_i1978].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_schema_req_args::~ThriftHiveMetastore_get_schema_req_args() noexcept { +} + +ThriftHiveMetastore_get_schema_req_args::ThriftHiveMetastore_get_schema_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_schema_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_schema_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_schema_req_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_schema_req_pargs::~ThriftHiveMetastore_get_schema_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_schema_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_schema_req_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_schema_req_result::~ThriftHiveMetastore_get_schema_req_result() noexcept { +} + +ThriftHiveMetastore_get_schema_req_result::ThriftHiveMetastore_get_schema_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_schema_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_schema_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_schema_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_schema_req_presult::~ThriftHiveMetastore_get_schema_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_schema_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_create_table_args::~ThriftHiveMetastore_create_table_args() noexcept { +} + +ThriftHiveMetastore_create_table_args::ThriftHiveMetastore_create_table_args() noexcept { +} + +uint32_t ThriftHiveMetastore_create_table_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->tbl.read(iprot); + this->__isset.tbl = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_table_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_table_args"); + + xfer += oprot->writeFieldBegin("tbl", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->tbl.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_table_pargs::~ThriftHiveMetastore_create_table_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_table_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_table_pargs"); + + xfer += oprot->writeFieldBegin("tbl", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->tbl)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_table_result::~ThriftHiveMetastore_create_table_result() noexcept { +} + +ThriftHiveMetastore_create_table_result::ThriftHiveMetastore_create_table_result() noexcept { +} + +uint32_t ThriftHiveMetastore_create_table_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_table_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_table_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_table_presult::~ThriftHiveMetastore_create_table_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_table_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_create_table_with_environment_context_args::~ThriftHiveMetastore_create_table_with_environment_context_args() noexcept { +} + +ThriftHiveMetastore_create_table_with_environment_context_args::ThriftHiveMetastore_create_table_with_environment_context_args() noexcept { +} + +uint32_t ThriftHiveMetastore_create_table_with_environment_context_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->tbl.read(iprot); + this->__isset.tbl = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->environment_context.read(iprot); + this->__isset.environment_context = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_table_with_environment_context_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_table_with_environment_context_args"); + + xfer += oprot->writeFieldBegin("tbl", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->tbl.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->environment_context.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_table_with_environment_context_pargs::~ThriftHiveMetastore_create_table_with_environment_context_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_table_with_environment_context_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_table_with_environment_context_pargs"); + + xfer += oprot->writeFieldBegin("tbl", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->tbl)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += (*(this->environment_context)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_table_with_environment_context_result::~ThriftHiveMetastore_create_table_with_environment_context_result() noexcept { +} + +ThriftHiveMetastore_create_table_with_environment_context_result::ThriftHiveMetastore_create_table_with_environment_context_result() noexcept { +} + +uint32_t ThriftHiveMetastore_create_table_with_environment_context_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_table_with_environment_context_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_table_with_environment_context_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_table_with_environment_context_presult::~ThriftHiveMetastore_create_table_with_environment_context_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_table_with_environment_context_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_create_table_with_constraints_args::~ThriftHiveMetastore_create_table_with_constraints_args() noexcept { +} + +ThriftHiveMetastore_create_table_with_constraints_args::ThriftHiveMetastore_create_table_with_constraints_args() noexcept { +} + +uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->tbl.read(iprot); + this->__isset.tbl = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->primaryKeys.clear(); + uint32_t _size1979; + ::apache::thrift::protocol::TType _etype1982; + xfer += iprot->readListBegin(_etype1982, _size1979); + this->primaryKeys.resize(_size1979); + uint32_t _i1983; + for (_i1983 = 0; _i1983 < _size1979; ++_i1983) + { + xfer += this->primaryKeys[_i1983].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.primaryKeys = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->foreignKeys.clear(); + uint32_t _size1984; + ::apache::thrift::protocol::TType _etype1987; + xfer += iprot->readListBegin(_etype1987, _size1984); + this->foreignKeys.resize(_size1984); + uint32_t _i1988; + for (_i1988 = 0; _i1988 < _size1984; ++_i1988) + { + xfer += this->foreignKeys[_i1988].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.foreignKeys = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->uniqueConstraints.clear(); + uint32_t _size1989; + ::apache::thrift::protocol::TType _etype1992; + xfer += iprot->readListBegin(_etype1992, _size1989); + this->uniqueConstraints.resize(_size1989); + uint32_t _i1993; + for (_i1993 = 0; _i1993 < _size1989; ++_i1993) + { + xfer += this->uniqueConstraints[_i1993].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.uniqueConstraints = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->notNullConstraints.clear(); + uint32_t _size1994; + ::apache::thrift::protocol::TType _etype1997; + xfer += iprot->readListBegin(_etype1997, _size1994); + this->notNullConstraints.resize(_size1994); + uint32_t _i1998; + for (_i1998 = 0; _i1998 < _size1994; ++_i1998) + { + xfer += this->notNullConstraints[_i1998].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.notNullConstraints = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->defaultConstraints.clear(); + uint32_t _size1999; + ::apache::thrift::protocol::TType _etype2002; + xfer += iprot->readListBegin(_etype2002, _size1999); + this->defaultConstraints.resize(_size1999); + uint32_t _i2003; + for (_i2003 = 0; _i2003 < _size1999; ++_i2003) + { + xfer += this->defaultConstraints[_i2003].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.defaultConstraints = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->checkConstraints.clear(); + uint32_t _size2004; + ::apache::thrift::protocol::TType _etype2007; + xfer += iprot->readListBegin(_etype2007, _size2004); + this->checkConstraints.resize(_size2004); + uint32_t _i2008; + for (_i2008 = 0; _i2008 < _size2004; ++_i2008) + { + xfer += this->checkConstraints[_i2008].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.checkConstraints = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_table_with_constraints_args"); + + xfer += oprot->writeFieldBegin("tbl", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->tbl.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->primaryKeys.size())); + std::vector ::const_iterator _iter2009; + for (_iter2009 = this->primaryKeys.begin(); _iter2009 != this->primaryKeys.end(); ++_iter2009) + { + xfer += (*_iter2009).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->foreignKeys.size())); + std::vector ::const_iterator _iter2010; + for (_iter2010 = this->foreignKeys.begin(); _iter2010 != this->foreignKeys.end(); ++_iter2010) + { + xfer += (*_iter2010).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->uniqueConstraints.size())); + std::vector ::const_iterator _iter2011; + for (_iter2011 = this->uniqueConstraints.begin(); _iter2011 != this->uniqueConstraints.end(); ++_iter2011) + { + xfer += (*_iter2011).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 5); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->notNullConstraints.size())); + std::vector ::const_iterator _iter2012; + for (_iter2012 = this->notNullConstraints.begin(); _iter2012 != this->notNullConstraints.end(); ++_iter2012) + { + xfer += (*_iter2012).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("defaultConstraints", ::apache::thrift::protocol::T_LIST, 6); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->defaultConstraints.size())); + std::vector ::const_iterator _iter2013; + for (_iter2013 = this->defaultConstraints.begin(); _iter2013 != this->defaultConstraints.end(); ++_iter2013) + { + xfer += (*_iter2013).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("checkConstraints", ::apache::thrift::protocol::T_LIST, 7); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->checkConstraints.size())); + std::vector ::const_iterator _iter2014; + for (_iter2014 = this->checkConstraints.begin(); _iter2014 != this->checkConstraints.end(); ++_iter2014) + { + xfer += (*_iter2014).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_table_with_constraints_pargs::~ThriftHiveMetastore_create_table_with_constraints_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_table_with_constraints_pargs"); + + xfer += oprot->writeFieldBegin("tbl", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->tbl)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->primaryKeys)).size())); + std::vector ::const_iterator _iter2015; + for (_iter2015 = (*(this->primaryKeys)).begin(); _iter2015 != (*(this->primaryKeys)).end(); ++_iter2015) + { + xfer += (*_iter2015).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->foreignKeys)).size())); + std::vector ::const_iterator _iter2016; + for (_iter2016 = (*(this->foreignKeys)).begin(); _iter2016 != (*(this->foreignKeys)).end(); ++_iter2016) + { + xfer += (*_iter2016).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->uniqueConstraints)).size())); + std::vector ::const_iterator _iter2017; + for (_iter2017 = (*(this->uniqueConstraints)).begin(); _iter2017 != (*(this->uniqueConstraints)).end(); ++_iter2017) + { + xfer += (*_iter2017).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 5); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->notNullConstraints)).size())); + std::vector ::const_iterator _iter2018; + for (_iter2018 = (*(this->notNullConstraints)).begin(); _iter2018 != (*(this->notNullConstraints)).end(); ++_iter2018) + { + xfer += (*_iter2018).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("defaultConstraints", ::apache::thrift::protocol::T_LIST, 6); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->defaultConstraints)).size())); + std::vector ::const_iterator _iter2019; + for (_iter2019 = (*(this->defaultConstraints)).begin(); _iter2019 != (*(this->defaultConstraints)).end(); ++_iter2019) + { + xfer += (*_iter2019).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("checkConstraints", ::apache::thrift::protocol::T_LIST, 7); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->checkConstraints)).size())); + std::vector ::const_iterator _iter2020; + for (_iter2020 = (*(this->checkConstraints)).begin(); _iter2020 != (*(this->checkConstraints)).end(); ++_iter2020) + { + xfer += (*_iter2020).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_table_with_constraints_result::~ThriftHiveMetastore_create_table_with_constraints_result() noexcept { +} + +ThriftHiveMetastore_create_table_with_constraints_result::ThriftHiveMetastore_create_table_with_constraints_result() noexcept { +} + +uint32_t ThriftHiveMetastore_create_table_with_constraints_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_table_with_constraints_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_table_with_constraints_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_table_with_constraints_presult::~ThriftHiveMetastore_create_table_with_constraints_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_table_with_constraints_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_create_table_req_args::~ThriftHiveMetastore_create_table_req_args() noexcept { +} + +ThriftHiveMetastore_create_table_req_args::ThriftHiveMetastore_create_table_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_create_table_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_table_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_table_req_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_table_req_pargs::~ThriftHiveMetastore_create_table_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_table_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_table_req_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_table_req_result::~ThriftHiveMetastore_create_table_req_result() noexcept { +} + +ThriftHiveMetastore_create_table_req_result::ThriftHiveMetastore_create_table_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_create_table_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_table_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_table_req_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_table_req_presult::~ThriftHiveMetastore_create_table_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_table_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_constraint_args::~ThriftHiveMetastore_drop_constraint_args() noexcept { +} + +ThriftHiveMetastore_drop_constraint_args::ThriftHiveMetastore_drop_constraint_args() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_constraint_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_constraint_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_constraint_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_constraint_pargs::~ThriftHiveMetastore_drop_constraint_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_constraint_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_constraint_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_constraint_result::~ThriftHiveMetastore_drop_constraint_result() noexcept { +} + +ThriftHiveMetastore_drop_constraint_result::ThriftHiveMetastore_drop_constraint_result() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_constraint_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_constraint_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_constraint_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_constraint_presult::~ThriftHiveMetastore_drop_constraint_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_constraint_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_primary_key_args::~ThriftHiveMetastore_add_primary_key_args() noexcept { +} + +ThriftHiveMetastore_add_primary_key_args::ThriftHiveMetastore_add_primary_key_args() noexcept { +} + +uint32_t ThriftHiveMetastore_add_primary_key_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_primary_key_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_primary_key_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_primary_key_pargs::~ThriftHiveMetastore_add_primary_key_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_primary_key_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_primary_key_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_primary_key_result::~ThriftHiveMetastore_add_primary_key_result() noexcept { +} + +ThriftHiveMetastore_add_primary_key_result::ThriftHiveMetastore_add_primary_key_result() noexcept { +} + +uint32_t ThriftHiveMetastore_add_primary_key_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_primary_key_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_primary_key_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_primary_key_presult::~ThriftHiveMetastore_add_primary_key_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_primary_key_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_foreign_key_args::~ThriftHiveMetastore_add_foreign_key_args() noexcept { +} + +ThriftHiveMetastore_add_foreign_key_args::ThriftHiveMetastore_add_foreign_key_args() noexcept { +} + +uint32_t ThriftHiveMetastore_add_foreign_key_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_foreign_key_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_foreign_key_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_foreign_key_pargs::~ThriftHiveMetastore_add_foreign_key_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_foreign_key_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_foreign_key_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_foreign_key_result::~ThriftHiveMetastore_add_foreign_key_result() noexcept { +} + +ThriftHiveMetastore_add_foreign_key_result::ThriftHiveMetastore_add_foreign_key_result() noexcept { +} + +uint32_t ThriftHiveMetastore_add_foreign_key_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_foreign_key_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_foreign_key_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_foreign_key_presult::~ThriftHiveMetastore_add_foreign_key_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_foreign_key_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_unique_constraint_args::~ThriftHiveMetastore_add_unique_constraint_args() noexcept { +} + +ThriftHiveMetastore_add_unique_constraint_args::ThriftHiveMetastore_add_unique_constraint_args() noexcept { +} + +uint32_t ThriftHiveMetastore_add_unique_constraint_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_unique_constraint_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_unique_constraint_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_unique_constraint_pargs::~ThriftHiveMetastore_add_unique_constraint_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_unique_constraint_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_unique_constraint_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_unique_constraint_result::~ThriftHiveMetastore_add_unique_constraint_result() noexcept { +} + +ThriftHiveMetastore_add_unique_constraint_result::ThriftHiveMetastore_add_unique_constraint_result() noexcept { +} + +uint32_t ThriftHiveMetastore_add_unique_constraint_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_unique_constraint_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_unique_constraint_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_unique_constraint_presult::~ThriftHiveMetastore_add_unique_constraint_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_unique_constraint_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_not_null_constraint_args::~ThriftHiveMetastore_add_not_null_constraint_args() noexcept { +} + +ThriftHiveMetastore_add_not_null_constraint_args::ThriftHiveMetastore_add_not_null_constraint_args() noexcept { +} + +uint32_t ThriftHiveMetastore_add_not_null_constraint_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_not_null_constraint_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_not_null_constraint_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_not_null_constraint_pargs::~ThriftHiveMetastore_add_not_null_constraint_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_not_null_constraint_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_not_null_constraint_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_not_null_constraint_result::~ThriftHiveMetastore_add_not_null_constraint_result() noexcept { +} + +ThriftHiveMetastore_add_not_null_constraint_result::ThriftHiveMetastore_add_not_null_constraint_result() noexcept { +} + +uint32_t ThriftHiveMetastore_add_not_null_constraint_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_not_null_constraint_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_not_null_constraint_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_not_null_constraint_presult::~ThriftHiveMetastore_add_not_null_constraint_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_not_null_constraint_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_default_constraint_args::~ThriftHiveMetastore_add_default_constraint_args() noexcept { +} + +ThriftHiveMetastore_add_default_constraint_args::ThriftHiveMetastore_add_default_constraint_args() noexcept { +} + +uint32_t ThriftHiveMetastore_add_default_constraint_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_default_constraint_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_default_constraint_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_default_constraint_pargs::~ThriftHiveMetastore_add_default_constraint_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_default_constraint_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_default_constraint_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_default_constraint_result::~ThriftHiveMetastore_add_default_constraint_result() noexcept { +} + +ThriftHiveMetastore_add_default_constraint_result::ThriftHiveMetastore_add_default_constraint_result() noexcept { +} + +uint32_t ThriftHiveMetastore_add_default_constraint_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_default_constraint_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_default_constraint_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_default_constraint_presult::~ThriftHiveMetastore_add_default_constraint_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_default_constraint_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_check_constraint_args::~ThriftHiveMetastore_add_check_constraint_args() noexcept { +} + +ThriftHiveMetastore_add_check_constraint_args::ThriftHiveMetastore_add_check_constraint_args() noexcept { +} + +uint32_t ThriftHiveMetastore_add_check_constraint_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_check_constraint_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_check_constraint_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_check_constraint_pargs::~ThriftHiveMetastore_add_check_constraint_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_check_constraint_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_check_constraint_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_check_constraint_result::~ThriftHiveMetastore_add_check_constraint_result() noexcept { +} + +ThriftHiveMetastore_add_check_constraint_result::ThriftHiveMetastore_add_check_constraint_result() noexcept { +} + +uint32_t ThriftHiveMetastore_add_check_constraint_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_check_constraint_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_check_constraint_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_check_constraint_presult::~ThriftHiveMetastore_add_check_constraint_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_check_constraint_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_translate_table_dryrun_args::~ThriftHiveMetastore_translate_table_dryrun_args() noexcept { +} + +ThriftHiveMetastore_translate_table_dryrun_args::ThriftHiveMetastore_translate_table_dryrun_args() noexcept { +} + +uint32_t ThriftHiveMetastore_translate_table_dryrun_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_translate_table_dryrun_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_translate_table_dryrun_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_translate_table_dryrun_pargs::~ThriftHiveMetastore_translate_table_dryrun_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_translate_table_dryrun_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_translate_table_dryrun_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_translate_table_dryrun_result::~ThriftHiveMetastore_translate_table_dryrun_result() noexcept { +} + +ThriftHiveMetastore_translate_table_dryrun_result::ThriftHiveMetastore_translate_table_dryrun_result() noexcept { +} + +uint32_t ThriftHiveMetastore_translate_table_dryrun_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_translate_table_dryrun_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_translate_table_dryrun_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_translate_table_dryrun_presult::~ThriftHiveMetastore_translate_table_dryrun_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_translate_table_dryrun_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_table_args::~ThriftHiveMetastore_drop_table_args() noexcept { +} + +ThriftHiveMetastore_drop_table_args::ThriftHiveMetastore_drop_table_args() noexcept + : dbname(), + name(), + deleteData(0) { +} + +uint32_t ThriftHiveMetastore_drop_table_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbname); + this->__isset.dbname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->deleteData); + this->__isset.deleteData = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_table_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_args"); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbname); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 3); + xfer += oprot->writeBool(this->deleteData); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_table_pargs::~ThriftHiveMetastore_drop_table_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_table_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_pargs"); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->dbname))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 3); + xfer += oprot->writeBool((*(this->deleteData))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_table_result::~ThriftHiveMetastore_drop_table_result() noexcept { +} + +ThriftHiveMetastore_drop_table_result::ThriftHiveMetastore_drop_table_result() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_table_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_table_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_table_presult::~ThriftHiveMetastore_drop_table_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_table_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_table_with_environment_context_args::~ThriftHiveMetastore_drop_table_with_environment_context_args() noexcept { +} + +ThriftHiveMetastore_drop_table_with_environment_context_args::ThriftHiveMetastore_drop_table_with_environment_context_args() noexcept + : dbname(), + name(), + deleteData(0) { +} + +uint32_t ThriftHiveMetastore_drop_table_with_environment_context_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbname); + this->__isset.dbname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->deleteData); + this->__isset.deleteData = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->environment_context.read(iprot); + this->__isset.environment_context = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_table_with_environment_context_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_with_environment_context_args"); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbname); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 3); + xfer += oprot->writeBool(this->deleteData); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->environment_context.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_table_with_environment_context_pargs::~ThriftHiveMetastore_drop_table_with_environment_context_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_table_with_environment_context_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_with_environment_context_pargs"); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->dbname))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 3); + xfer += oprot->writeBool((*(this->deleteData))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += (*(this->environment_context)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_table_with_environment_context_result::~ThriftHiveMetastore_drop_table_with_environment_context_result() noexcept { +} + +ThriftHiveMetastore_drop_table_with_environment_context_result::ThriftHiveMetastore_drop_table_with_environment_context_result() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_table_with_environment_context_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_table_with_environment_context_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_with_environment_context_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_table_with_environment_context_presult::~ThriftHiveMetastore_drop_table_with_environment_context_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_table_with_environment_context_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_table_req_args::~ThriftHiveMetastore_drop_table_req_args() noexcept { +} + +ThriftHiveMetastore_drop_table_req_args::ThriftHiveMetastore_drop_table_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_table_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->dropTableReq.read(iprot); + this->__isset.dropTableReq = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_table_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_req_args"); + + xfer += oprot->writeFieldBegin("dropTableReq", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->dropTableReq.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_table_req_pargs::~ThriftHiveMetastore_drop_table_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_table_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_req_pargs"); + + xfer += oprot->writeFieldBegin("dropTableReq", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->dropTableReq)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_table_req_result::~ThriftHiveMetastore_drop_table_req_result() noexcept { +} + +ThriftHiveMetastore_drop_table_req_result::ThriftHiveMetastore_drop_table_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_table_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_table_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_req_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_table_req_presult::~ThriftHiveMetastore_drop_table_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_table_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_truncate_table_args::~ThriftHiveMetastore_truncate_table_args() noexcept { +} + +ThriftHiveMetastore_truncate_table_args::ThriftHiveMetastore_truncate_table_args() noexcept + : dbName(), + tableName() { +} + +uint32_t ThriftHiveMetastore_truncate_table_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + this->__isset.tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partNames.clear(); + uint32_t _size2021; + ::apache::thrift::protocol::TType _etype2024; + xfer += iprot->readListBegin(_etype2024, _size2021); + this->partNames.resize(_size2021); + uint32_t _i2025; + for (_i2025 = 0; _i2025 < _size2021; ++_i2025) + { + xfer += iprot->readString(this->partNames[_i2025]); + } + xfer += iprot->readListEnd(); + } + this->__isset.partNames = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_truncate_table_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_truncate_table_args"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partNames.size())); + std::vector ::const_iterator _iter2026; + for (_iter2026 = this->partNames.begin(); _iter2026 != this->partNames.end(); ++_iter2026) + { + xfer += oprot->writeString((*_iter2026)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_truncate_table_pargs::~ThriftHiveMetastore_truncate_table_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_truncate_table_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_truncate_table_pargs"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->dbName))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tableName))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->partNames)).size())); + std::vector ::const_iterator _iter2027; + for (_iter2027 = (*(this->partNames)).begin(); _iter2027 != (*(this->partNames)).end(); ++_iter2027) + { + xfer += oprot->writeString((*_iter2027)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_truncate_table_result::~ThriftHiveMetastore_truncate_table_result() noexcept { +} + +ThriftHiveMetastore_truncate_table_result::ThriftHiveMetastore_truncate_table_result() noexcept { +} + +uint32_t ThriftHiveMetastore_truncate_table_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_truncate_table_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_truncate_table_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_truncate_table_presult::~ThriftHiveMetastore_truncate_table_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_truncate_table_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_truncate_table_req_args::~ThriftHiveMetastore_truncate_table_req_args() noexcept { +} + +ThriftHiveMetastore_truncate_table_req_args::ThriftHiveMetastore_truncate_table_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_truncate_table_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_truncate_table_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_truncate_table_req_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_truncate_table_req_pargs::~ThriftHiveMetastore_truncate_table_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_truncate_table_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_truncate_table_req_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_truncate_table_req_result::~ThriftHiveMetastore_truncate_table_req_result() noexcept { +} + +ThriftHiveMetastore_truncate_table_req_result::ThriftHiveMetastore_truncate_table_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_truncate_table_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_truncate_table_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_truncate_table_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_truncate_table_req_presult::~ThriftHiveMetastore_truncate_table_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_truncate_table_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_tables_args::~ThriftHiveMetastore_get_tables_args() noexcept { +} + +ThriftHiveMetastore_get_tables_args::ThriftHiveMetastore_get_tables_args() noexcept + : db_name(), + pattern() { +} + +uint32_t ThriftHiveMetastore_get_tables_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->pattern); + this->__isset.pattern = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_tables_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("pattern", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->pattern); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_tables_pargs::~ThriftHiveMetastore_get_tables_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_tables_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("pattern", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->pattern))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_tables_result::~ThriftHiveMetastore_get_tables_result() noexcept { +} + +ThriftHiveMetastore_get_tables_result::ThriftHiveMetastore_get_tables_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2028; + ::apache::thrift::protocol::TType _etype2031; + xfer += iprot->readListBegin(_etype2031, _size2028); + this->success.resize(_size2028); + uint32_t _i2032; + for (_i2032 = 0; _i2032 < _size2028; ++_i2032) + { + xfer += iprot->readString(this->success[_i2032]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_tables_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::vector ::const_iterator _iter2033; + for (_iter2033 = this->success.begin(); _iter2033 != this->success.end(); ++_iter2033) + { + xfer += oprot->writeString((*_iter2033)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_tables_presult::~ThriftHiveMetastore_get_tables_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2034; + ::apache::thrift::protocol::TType _etype2037; + xfer += iprot->readListBegin(_etype2037, _size2034); + (*(this->success)).resize(_size2034); + uint32_t _i2038; + for (_i2038 = 0; _i2038 < _size2034; ++_i2038) + { + xfer += iprot->readString((*(this->success))[_i2038]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_tables_by_type_args::~ThriftHiveMetastore_get_tables_by_type_args() noexcept { +} + +ThriftHiveMetastore_get_tables_by_type_args::ThriftHiveMetastore_get_tables_by_type_args() noexcept + : db_name(), + pattern(), + tableType() { +} + +uint32_t ThriftHiveMetastore_get_tables_by_type_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->pattern); + this->__isset.pattern = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableType); + this->__isset.tableType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_tables_by_type_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_by_type_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("pattern", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->pattern); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableType", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tableType); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_tables_by_type_pargs::~ThriftHiveMetastore_get_tables_by_type_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_tables_by_type_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_by_type_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("pattern", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->pattern))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableType", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->tableType))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_tables_by_type_result::~ThriftHiveMetastore_get_tables_by_type_result() noexcept { +} + +ThriftHiveMetastore_get_tables_by_type_result::ThriftHiveMetastore_get_tables_by_type_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_tables_by_type_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2039; + ::apache::thrift::protocol::TType _etype2042; + xfer += iprot->readListBegin(_etype2042, _size2039); + this->success.resize(_size2039); + uint32_t _i2043; + for (_i2043 = 0; _i2043 < _size2039; ++_i2043) + { + xfer += iprot->readString(this->success[_i2043]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_tables_by_type_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_by_type_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::vector ::const_iterator _iter2044; + for (_iter2044 = this->success.begin(); _iter2044 != this->success.end(); ++_iter2044) + { + xfer += oprot->writeString((*_iter2044)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_tables_by_type_presult::~ThriftHiveMetastore_get_tables_by_type_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2045; + ::apache::thrift::protocol::TType _etype2048; + xfer += iprot->readListBegin(_etype2048, _size2045); + (*(this->success)).resize(_size2045); + uint32_t _i2049; + for (_i2049 = 0; _i2049 < _size2045; ++_i2049) + { + xfer += iprot->readString((*(this->success))[_i2049]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_args::~ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_args() noexcept { +} + +ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_args::ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_pargs::~ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_result::~ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_result() noexcept { +} + +ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_result::ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2050; + ::apache::thrift::protocol::TType _etype2053; + xfer += iprot->readListBegin(_etype2053, _size2050); + this->success.resize(_size2050); + uint32_t _i2054; + for (_i2054 = 0; _i2054 < _size2050; ++_i2054) + { + xfer += this->success[_i2054].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter2055; + for (_iter2055 = this->success.begin(); _iter2055 != this->success.end(); ++_iter2055) + { + xfer += (*_iter2055).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_presult::~ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2056; + ::apache::thrift::protocol::TType _etype2059; + xfer += iprot->readListBegin(_etype2059, _size2056); + (*(this->success)).resize(_size2056); + uint32_t _i2060; + for (_i2060 = 0; _i2060 < _size2056; ++_i2060) + { + xfer += (*(this->success))[_i2060].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_materialized_views_for_rewriting_args::~ThriftHiveMetastore_get_materialized_views_for_rewriting_args() noexcept { +} + +ThriftHiveMetastore_get_materialized_views_for_rewriting_args::ThriftHiveMetastore_get_materialized_views_for_rewriting_args() noexcept + : db_name() { +} + +uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_materialized_views_for_rewriting_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_materialized_views_for_rewriting_pargs::~ThriftHiveMetastore_get_materialized_views_for_rewriting_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_materialized_views_for_rewriting_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_materialized_views_for_rewriting_result::~ThriftHiveMetastore_get_materialized_views_for_rewriting_result() noexcept { +} + +ThriftHiveMetastore_get_materialized_views_for_rewriting_result::ThriftHiveMetastore_get_materialized_views_for_rewriting_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2061; + ::apache::thrift::protocol::TType _etype2064; + xfer += iprot->readListBegin(_etype2064, _size2061); + this->success.resize(_size2061); + uint32_t _i2065; + for (_i2065 = 0; _i2065 < _size2061; ++_i2065) + { + xfer += iprot->readString(this->success[_i2065]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_materialized_views_for_rewriting_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::vector ::const_iterator _iter2066; + for (_iter2066 = this->success.begin(); _iter2066 != this->success.end(); ++_iter2066) + { + xfer += oprot->writeString((*_iter2066)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_materialized_views_for_rewriting_presult::~ThriftHiveMetastore_get_materialized_views_for_rewriting_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2067; + ::apache::thrift::protocol::TType _etype2070; + xfer += iprot->readListBegin(_etype2070, _size2067); + (*(this->success)).resize(_size2067); + uint32_t _i2071; + for (_i2071 = 0; _i2071 < _size2067; ++_i2071) + { + xfer += iprot->readString((*(this->success))[_i2071]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_table_meta_args::~ThriftHiveMetastore_get_table_meta_args() noexcept { +} + +ThriftHiveMetastore_get_table_meta_args::ThriftHiveMetastore_get_table_meta_args() noexcept + : db_patterns(), + tbl_patterns() { +} + +uint32_t ThriftHiveMetastore_get_table_meta_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_patterns); + this->__isset.db_patterns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_patterns); + this->__isset.tbl_patterns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->tbl_types.clear(); + uint32_t _size2072; + ::apache::thrift::protocol::TType _etype2075; + xfer += iprot->readListBegin(_etype2075, _size2072); + this->tbl_types.resize(_size2072); + uint32_t _i2076; + for (_i2076 = 0; _i2076 < _size2072; ++_i2076) + { + xfer += iprot->readString(this->tbl_types[_i2076]); + } + xfer += iprot->readListEnd(); + } + this->__isset.tbl_types = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_table_meta_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_table_meta_args"); + + xfer += oprot->writeFieldBegin("db_patterns", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_patterns); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_patterns", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_patterns); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tbl_types.size())); + std::vector ::const_iterator _iter2077; + for (_iter2077 = this->tbl_types.begin(); _iter2077 != this->tbl_types.end(); ++_iter2077) + { + xfer += oprot->writeString((*_iter2077)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_table_meta_pargs::~ThriftHiveMetastore_get_table_meta_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_table_meta_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_table_meta_pargs"); + + xfer += oprot->writeFieldBegin("db_patterns", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_patterns))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_patterns", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_patterns))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->tbl_types)).size())); + std::vector ::const_iterator _iter2078; + for (_iter2078 = (*(this->tbl_types)).begin(); _iter2078 != (*(this->tbl_types)).end(); ++_iter2078) + { + xfer += oprot->writeString((*_iter2078)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_table_meta_result::~ThriftHiveMetastore_get_table_meta_result() noexcept { +} + +ThriftHiveMetastore_get_table_meta_result::ThriftHiveMetastore_get_table_meta_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2079; + ::apache::thrift::protocol::TType _etype2082; + xfer += iprot->readListBegin(_etype2082, _size2079); + this->success.resize(_size2079); + uint32_t _i2083; + for (_i2083 = 0; _i2083 < _size2079; ++_i2083) + { + xfer += this->success[_i2083].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_table_meta_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_table_meta_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter2084; + for (_iter2084 = this->success.begin(); _iter2084 != this->success.end(); ++_iter2084) + { + xfer += (*_iter2084).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_table_meta_presult::~ThriftHiveMetastore_get_table_meta_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2085; + ::apache::thrift::protocol::TType _etype2088; + xfer += iprot->readListBegin(_etype2088, _size2085); + (*(this->success)).resize(_size2085); + uint32_t _i2089; + for (_i2089 = 0; _i2089 < _size2085; ++_i2089) + { + xfer += (*(this->success))[_i2089].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_all_tables_args::~ThriftHiveMetastore_get_all_tables_args() noexcept { +} + +ThriftHiveMetastore_get_all_tables_args::ThriftHiveMetastore_get_all_tables_args() noexcept + : db_name() { +} + +uint32_t ThriftHiveMetastore_get_all_tables_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_all_tables_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_tables_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_tables_pargs::~ThriftHiveMetastore_get_all_tables_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_all_tables_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_tables_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_tables_result::~ThriftHiveMetastore_get_all_tables_result() noexcept { +} + +ThriftHiveMetastore_get_all_tables_result::ThriftHiveMetastore_get_all_tables_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2090; + ::apache::thrift::protocol::TType _etype2093; + xfer += iprot->readListBegin(_etype2093, _size2090); + this->success.resize(_size2090); + uint32_t _i2094; + for (_i2094 = 0; _i2094 < _size2090; ++_i2094) + { + xfer += iprot->readString(this->success[_i2094]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_all_tables_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_tables_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::vector ::const_iterator _iter2095; + for (_iter2095 = this->success.begin(); _iter2095 != this->success.end(); ++_iter2095) + { + xfer += oprot->writeString((*_iter2095)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_tables_presult::~ThriftHiveMetastore_get_all_tables_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2096; + ::apache::thrift::protocol::TType _etype2099; + xfer += iprot->readListBegin(_etype2099, _size2096); + (*(this->success)).resize(_size2096); + uint32_t _i2100; + for (_i2100 = 0; _i2100 < _size2096; ++_i2100) + { + xfer += iprot->readString((*(this->success))[_i2100]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_tables_ext_args::~ThriftHiveMetastore_get_tables_ext_args() noexcept { +} + +ThriftHiveMetastore_get_tables_ext_args::ThriftHiveMetastore_get_tables_ext_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_tables_ext_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_tables_ext_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_ext_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_tables_ext_pargs::~ThriftHiveMetastore_get_tables_ext_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_tables_ext_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_ext_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_tables_ext_result::~ThriftHiveMetastore_get_tables_ext_result() noexcept { +} + +ThriftHiveMetastore_get_tables_ext_result::ThriftHiveMetastore_get_tables_ext_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_tables_ext_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2101; + ::apache::thrift::protocol::TType _etype2104; + xfer += iprot->readListBegin(_etype2104, _size2101); + this->success.resize(_size2101); + uint32_t _i2105; + for (_i2105 = 0; _i2105 < _size2101; ++_i2105) + { + xfer += this->success[_i2105].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_tables_ext_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_ext_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter2106; + for (_iter2106 = this->success.begin(); _iter2106 != this->success.end(); ++_iter2106) + { + xfer += (*_iter2106).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_tables_ext_presult::~ThriftHiveMetastore_get_tables_ext_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_tables_ext_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2107; + ::apache::thrift::protocol::TType _etype2110; + xfer += iprot->readListBegin(_etype2110, _size2107); + (*(this->success)).resize(_size2107); + uint32_t _i2111; + for (_i2111 = 0; _i2111 < _size2107; ++_i2111) + { + xfer += (*(this->success))[_i2111].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_table_req_args::~ThriftHiveMetastore_get_table_req_args() noexcept { +} + +ThriftHiveMetastore_get_table_req_args::ThriftHiveMetastore_get_table_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_table_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_table_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_table_req_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_table_req_pargs::~ThriftHiveMetastore_get_table_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_table_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_table_req_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_table_req_result::~ThriftHiveMetastore_get_table_req_result() noexcept { +} + +ThriftHiveMetastore_get_table_req_result::ThriftHiveMetastore_get_table_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_table_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_table_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_table_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_table_req_presult::~ThriftHiveMetastore_get_table_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_table_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_table_objects_by_name_req_args::~ThriftHiveMetastore_get_table_objects_by_name_req_args() noexcept { +} + +ThriftHiveMetastore_get_table_objects_by_name_req_args::ThriftHiveMetastore_get_table_objects_by_name_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_table_objects_by_name_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_table_objects_by_name_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_table_objects_by_name_req_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_table_objects_by_name_req_pargs::~ThriftHiveMetastore_get_table_objects_by_name_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_table_objects_by_name_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_table_objects_by_name_req_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_table_objects_by_name_req_result::~ThriftHiveMetastore_get_table_objects_by_name_req_result() noexcept { +} + +ThriftHiveMetastore_get_table_objects_by_name_req_result::ThriftHiveMetastore_get_table_objects_by_name_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_table_objects_by_name_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_table_objects_by_name_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_table_objects_by_name_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_table_objects_by_name_req_presult::~ThriftHiveMetastore_get_table_objects_by_name_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_table_objects_by_name_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_materialization_invalidation_info_args::~ThriftHiveMetastore_get_materialization_invalidation_info_args() noexcept { +} + +ThriftHiveMetastore_get_materialization_invalidation_info_args::ThriftHiveMetastore_get_materialization_invalidation_info_args() noexcept + : validTxnList() { +} + +uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->creation_metadata.read(iprot); + this->__isset.creation_metadata = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validTxnList); + this->__isset.validTxnList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_materialization_invalidation_info_args"); + + xfer += oprot->writeFieldBegin("creation_metadata", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->creation_metadata.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("validTxnList", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->validTxnList); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_materialization_invalidation_info_pargs::~ThriftHiveMetastore_get_materialization_invalidation_info_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_materialization_invalidation_info_pargs"); + + xfer += oprot->writeFieldBegin("creation_metadata", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->creation_metadata)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("validTxnList", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->validTxnList))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_materialization_invalidation_info_result::~ThriftHiveMetastore_get_materialization_invalidation_info_result() noexcept { +} + +ThriftHiveMetastore_get_materialization_invalidation_info_result::ThriftHiveMetastore_get_materialization_invalidation_info_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_materialization_invalidation_info_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_materialization_invalidation_info_presult::~ThriftHiveMetastore_get_materialization_invalidation_info_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_update_creation_metadata_args::~ThriftHiveMetastore_update_creation_metadata_args() noexcept { +} + +ThriftHiveMetastore_update_creation_metadata_args::ThriftHiveMetastore_update_creation_metadata_args() noexcept + : catName(), + dbname(), + tbl_name() { +} + +uint32_t ThriftHiveMetastore_update_creation_metadata_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbname); + this->__isset.dbname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->creation_metadata.read(iprot); + this->__isset.creation_metadata = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_update_creation_metadata_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_creation_metadata_args"); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbname); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("creation_metadata", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->creation_metadata.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_creation_metadata_pargs::~ThriftHiveMetastore_update_creation_metadata_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_update_creation_metadata_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_creation_metadata_pargs"); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->catName))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->dbname))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("creation_metadata", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += (*(this->creation_metadata)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_creation_metadata_result::~ThriftHiveMetastore_update_creation_metadata_result() noexcept { +} + +ThriftHiveMetastore_update_creation_metadata_result::ThriftHiveMetastore_update_creation_metadata_result() noexcept { +} + +uint32_t ThriftHiveMetastore_update_creation_metadata_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_update_creation_metadata_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_creation_metadata_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_creation_metadata_presult::~ThriftHiveMetastore_update_creation_metadata_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_update_creation_metadata_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_table_names_by_filter_args::~ThriftHiveMetastore_get_table_names_by_filter_args() noexcept { +} + +ThriftHiveMetastore_get_table_names_by_filter_args::ThriftHiveMetastore_get_table_names_by_filter_args() noexcept + : dbname(), + filter(), + max_tables(-1) { +} + +uint32_t ThriftHiveMetastore_get_table_names_by_filter_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbname); + this->__isset.dbname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->filter); + this->__isset.filter = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I16) { + xfer += iprot->readI16(this->max_tables); + this->__isset.max_tables = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_table_names_by_filter_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_table_names_by_filter_args"); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbname); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("filter", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->filter); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_tables", ::apache::thrift::protocol::T_I16, 3); + xfer += oprot->writeI16(this->max_tables); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_table_names_by_filter_pargs::~ThriftHiveMetastore_get_table_names_by_filter_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_table_names_by_filter_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_table_names_by_filter_pargs"); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->dbname))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("filter", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->filter))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_tables", ::apache::thrift::protocol::T_I16, 3); + xfer += oprot->writeI16((*(this->max_tables))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_table_names_by_filter_result::~ThriftHiveMetastore_get_table_names_by_filter_result() noexcept { +} + +ThriftHiveMetastore_get_table_names_by_filter_result::ThriftHiveMetastore_get_table_names_by_filter_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_table_names_by_filter_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2112; + ::apache::thrift::protocol::TType _etype2115; + xfer += iprot->readListBegin(_etype2115, _size2112); + this->success.resize(_size2112); + uint32_t _i2116; + for (_i2116 = 0; _i2116 < _size2112; ++_i2116) + { + xfer += iprot->readString(this->success[_i2116]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_table_names_by_filter_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_table_names_by_filter_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::vector ::const_iterator _iter2117; + for (_iter2117 = this->success.begin(); _iter2117 != this->success.end(); ++_iter2117) + { + xfer += oprot->writeString((*_iter2117)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_table_names_by_filter_presult::~ThriftHiveMetastore_get_table_names_by_filter_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_table_names_by_filter_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2118; + ::apache::thrift::protocol::TType _etype2121; + xfer += iprot->readListBegin(_etype2121, _size2118); + (*(this->success)).resize(_size2118); + uint32_t _i2122; + for (_i2122 = 0; _i2122 < _size2118; ++_i2122) + { + xfer += iprot->readString((*(this->success))[_i2122]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_alter_table_args::~ThriftHiveMetastore_alter_table_args() noexcept { +} + +ThriftHiveMetastore_alter_table_args::ThriftHiveMetastore_alter_table_args() noexcept + : dbname(), + tbl_name() { +} + +uint32_t ThriftHiveMetastore_alter_table_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbname); + this->__isset.dbname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->new_tbl.read(iprot); + this->__isset.new_tbl = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_table_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_table_args"); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbname); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("new_tbl", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->new_tbl.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_table_pargs::~ThriftHiveMetastore_alter_table_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_table_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_table_pargs"); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->dbname))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("new_tbl", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += (*(this->new_tbl)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_table_result::~ThriftHiveMetastore_alter_table_result() noexcept { +} + +ThriftHiveMetastore_alter_table_result::ThriftHiveMetastore_alter_table_result() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_table_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_table_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_table_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_table_presult::~ThriftHiveMetastore_alter_table_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_table_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_alter_table_with_environment_context_args::~ThriftHiveMetastore_alter_table_with_environment_context_args() noexcept { +} + +ThriftHiveMetastore_alter_table_with_environment_context_args::ThriftHiveMetastore_alter_table_with_environment_context_args() noexcept + : dbname(), + tbl_name() { +} + +uint32_t ThriftHiveMetastore_alter_table_with_environment_context_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbname); + this->__isset.dbname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->new_tbl.read(iprot); + this->__isset.new_tbl = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->environment_context.read(iprot); + this->__isset.environment_context = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_table_with_environment_context_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_table_with_environment_context_args"); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbname); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("new_tbl", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->new_tbl.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->environment_context.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_table_with_environment_context_pargs::~ThriftHiveMetastore_alter_table_with_environment_context_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_table_with_environment_context_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_table_with_environment_context_pargs"); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->dbname))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("new_tbl", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += (*(this->new_tbl)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += (*(this->environment_context)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_table_with_environment_context_result::~ThriftHiveMetastore_alter_table_with_environment_context_result() noexcept { +} + +ThriftHiveMetastore_alter_table_with_environment_context_result::ThriftHiveMetastore_alter_table_with_environment_context_result() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_table_with_environment_context_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_table_with_environment_context_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_table_with_environment_context_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_table_with_environment_context_presult::~ThriftHiveMetastore_alter_table_with_environment_context_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_table_with_environment_context_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_alter_table_with_cascade_args::~ThriftHiveMetastore_alter_table_with_cascade_args() noexcept { +} + +ThriftHiveMetastore_alter_table_with_cascade_args::ThriftHiveMetastore_alter_table_with_cascade_args() noexcept + : dbname(), + tbl_name(), + cascade(0) { +} + +uint32_t ThriftHiveMetastore_alter_table_with_cascade_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbname); + this->__isset.dbname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->new_tbl.read(iprot); + this->__isset.new_tbl = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->cascade); + this->__isset.cascade = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_table_with_cascade_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_table_with_cascade_args"); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbname); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("new_tbl", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->new_tbl.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("cascade", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool(this->cascade); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_table_with_cascade_pargs::~ThriftHiveMetastore_alter_table_with_cascade_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_table_with_cascade_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_table_with_cascade_pargs"); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->dbname))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("new_tbl", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += (*(this->new_tbl)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("cascade", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool((*(this->cascade))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_table_with_cascade_result::~ThriftHiveMetastore_alter_table_with_cascade_result() noexcept { +} + +ThriftHiveMetastore_alter_table_with_cascade_result::ThriftHiveMetastore_alter_table_with_cascade_result() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_table_with_cascade_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_table_with_cascade_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_table_with_cascade_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_table_with_cascade_presult::~ThriftHiveMetastore_alter_table_with_cascade_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_table_with_cascade_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_alter_table_req_args::~ThriftHiveMetastore_alter_table_req_args() noexcept { +} + +ThriftHiveMetastore_alter_table_req_args::ThriftHiveMetastore_alter_table_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_table_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_table_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_table_req_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_table_req_pargs::~ThriftHiveMetastore_alter_table_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_table_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_table_req_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_table_req_result::~ThriftHiveMetastore_alter_table_req_result() noexcept { +} + +ThriftHiveMetastore_alter_table_req_result::ThriftHiveMetastore_alter_table_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_table_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_table_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_table_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_table_req_presult::~ThriftHiveMetastore_alter_table_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_table_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_partition_args::~ThriftHiveMetastore_add_partition_args() noexcept { +} + +ThriftHiveMetastore_add_partition_args::ThriftHiveMetastore_add_partition_args() noexcept { +} + +uint32_t ThriftHiveMetastore_add_partition_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->new_part.read(iprot); + this->__isset.new_part = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_partition_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partition_args"); + + xfer += oprot->writeFieldBegin("new_part", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->new_part.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_partition_pargs::~ThriftHiveMetastore_add_partition_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_partition_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partition_pargs"); + + xfer += oprot->writeFieldBegin("new_part", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->new_part)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_partition_result::~ThriftHiveMetastore_add_partition_result() noexcept { +} + +ThriftHiveMetastore_add_partition_result::ThriftHiveMetastore_add_partition_result() noexcept { +} + +uint32_t ThriftHiveMetastore_add_partition_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_partition_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partition_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_partition_presult::~ThriftHiveMetastore_add_partition_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_partition_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_partition_with_environment_context_args::~ThriftHiveMetastore_add_partition_with_environment_context_args() noexcept { +} + +ThriftHiveMetastore_add_partition_with_environment_context_args::ThriftHiveMetastore_add_partition_with_environment_context_args() noexcept { +} + +uint32_t ThriftHiveMetastore_add_partition_with_environment_context_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->new_part.read(iprot); + this->__isset.new_part = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->environment_context.read(iprot); + this->__isset.environment_context = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_partition_with_environment_context_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partition_with_environment_context_args"); + + xfer += oprot->writeFieldBegin("new_part", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->new_part.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->environment_context.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_partition_with_environment_context_pargs::~ThriftHiveMetastore_add_partition_with_environment_context_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_partition_with_environment_context_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partition_with_environment_context_pargs"); + + xfer += oprot->writeFieldBegin("new_part", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->new_part)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += (*(this->environment_context)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_partition_with_environment_context_result::~ThriftHiveMetastore_add_partition_with_environment_context_result() noexcept { +} + +ThriftHiveMetastore_add_partition_with_environment_context_result::ThriftHiveMetastore_add_partition_with_environment_context_result() noexcept { +} + +uint32_t ThriftHiveMetastore_add_partition_with_environment_context_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_partition_with_environment_context_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partition_with_environment_context_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_partition_with_environment_context_presult::~ThriftHiveMetastore_add_partition_with_environment_context_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_partition_with_environment_context_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_partitions_args::~ThriftHiveMetastore_add_partitions_args() noexcept { +} + +ThriftHiveMetastore_add_partitions_args::ThriftHiveMetastore_add_partitions_args() noexcept { +} + +uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->new_parts.clear(); + uint32_t _size2123; + ::apache::thrift::protocol::TType _etype2126; + xfer += iprot->readListBegin(_etype2126, _size2123); + this->new_parts.resize(_size2123); + uint32_t _i2127; + for (_i2127 = 0; _i2127 < _size2123; ++_i2127) + { + xfer += this->new_parts[_i2127].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.new_parts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_partitions_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partitions_args"); + + xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); + std::vector ::const_iterator _iter2128; + for (_iter2128 = this->new_parts.begin(); _iter2128 != this->new_parts.end(); ++_iter2128) + { + xfer += (*_iter2128).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_partitions_pargs::~ThriftHiveMetastore_add_partitions_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_partitions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partitions_pargs"); + + xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); + std::vector ::const_iterator _iter2129; + for (_iter2129 = (*(this->new_parts)).begin(); _iter2129 != (*(this->new_parts)).end(); ++_iter2129) + { + xfer += (*_iter2129).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_partitions_result::~ThriftHiveMetastore_add_partitions_result() noexcept { +} + +ThriftHiveMetastore_add_partitions_result::ThriftHiveMetastore_add_partitions_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_add_partitions_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_partitions_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partitions_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0); + xfer += oprot->writeI32(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_partitions_presult::~ThriftHiveMetastore_add_partitions_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_partitions_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_partitions_pspec_args::~ThriftHiveMetastore_add_partitions_pspec_args() noexcept { +} + +ThriftHiveMetastore_add_partitions_pspec_args::ThriftHiveMetastore_add_partitions_pspec_args() noexcept { +} + +uint32_t ThriftHiveMetastore_add_partitions_pspec_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->new_parts.clear(); + uint32_t _size2130; + ::apache::thrift::protocol::TType _etype2133; + xfer += iprot->readListBegin(_etype2133, _size2130); + this->new_parts.resize(_size2130); + uint32_t _i2134; + for (_i2134 = 0; _i2134 < _size2130; ++_i2134) + { + xfer += this->new_parts[_i2134].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.new_parts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_partitions_pspec_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partitions_pspec_args"); + + xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); + std::vector ::const_iterator _iter2135; + for (_iter2135 = this->new_parts.begin(); _iter2135 != this->new_parts.end(); ++_iter2135) + { + xfer += (*_iter2135).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_partitions_pspec_pargs::~ThriftHiveMetastore_add_partitions_pspec_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_partitions_pspec_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partitions_pspec_pargs"); + + xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); + std::vector ::const_iterator _iter2136; + for (_iter2136 = (*(this->new_parts)).begin(); _iter2136 != (*(this->new_parts)).end(); ++_iter2136) + { + xfer += (*_iter2136).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_partitions_pspec_result::~ThriftHiveMetastore_add_partitions_pspec_result() noexcept { +} + +ThriftHiveMetastore_add_partitions_pspec_result::ThriftHiveMetastore_add_partitions_pspec_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_add_partitions_pspec_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_partitions_pspec_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partitions_pspec_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0); + xfer += oprot->writeI32(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_partitions_pspec_presult::~ThriftHiveMetastore_add_partitions_pspec_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_partitions_pspec_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_append_partition_args::~ThriftHiveMetastore_append_partition_args() noexcept { +} + +ThriftHiveMetastore_append_partition_args::ThriftHiveMetastore_append_partition_args() noexcept + : db_name(), + tbl_name() { +} + +uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->part_vals.clear(); + uint32_t _size2137; + ::apache::thrift::protocol::TType _etype2140; + xfer += iprot->readListBegin(_etype2140, _size2137); + this->part_vals.resize(_size2137); + uint32_t _i2141; + for (_i2141 = 0; _i2141 < _size2137; ++_i2141) + { + xfer += iprot->readString(this->part_vals[_i2141]); + } + xfer += iprot->readListEnd(); + } + this->__isset.part_vals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_append_partition_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); + std::vector ::const_iterator _iter2142; + for (_iter2142 = this->part_vals.begin(); _iter2142 != this->part_vals.end(); ++_iter2142) + { + xfer += oprot->writeString((*_iter2142)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_append_partition_pargs::~ThriftHiveMetastore_append_partition_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_append_partition_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); + std::vector ::const_iterator _iter2143; + for (_iter2143 = (*(this->part_vals)).begin(); _iter2143 != (*(this->part_vals)).end(); ++_iter2143) + { + xfer += oprot->writeString((*_iter2143)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_append_partition_result::~ThriftHiveMetastore_append_partition_result() noexcept { +} + +ThriftHiveMetastore_append_partition_result::ThriftHiveMetastore_append_partition_result() noexcept { +} + +uint32_t ThriftHiveMetastore_append_partition_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_append_partition_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_append_partition_presult::~ThriftHiveMetastore_append_partition_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_append_partition_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_partitions_req_args::~ThriftHiveMetastore_add_partitions_req_args() noexcept { +} + +ThriftHiveMetastore_add_partitions_req_args::ThriftHiveMetastore_add_partitions_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_add_partitions_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_partitions_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partitions_req_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_partitions_req_pargs::~ThriftHiveMetastore_add_partitions_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_partitions_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partitions_req_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_partitions_req_result::~ThriftHiveMetastore_add_partitions_req_result() noexcept { +} + +ThriftHiveMetastore_add_partitions_req_result::ThriftHiveMetastore_add_partitions_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_add_partitions_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_partitions_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partitions_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_partitions_req_presult::~ThriftHiveMetastore_add_partitions_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_partitions_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_append_partition_with_environment_context_args::~ThriftHiveMetastore_append_partition_with_environment_context_args() noexcept { +} + +ThriftHiveMetastore_append_partition_with_environment_context_args::ThriftHiveMetastore_append_partition_with_environment_context_args() noexcept + : db_name(), + tbl_name() { +} + +uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->part_vals.clear(); + uint32_t _size2144; + ::apache::thrift::protocol::TType _etype2147; + xfer += iprot->readListBegin(_etype2147, _size2144); + this->part_vals.resize(_size2144); + uint32_t _i2148; + for (_i2148 = 0; _i2148 < _size2144; ++_i2148) + { + xfer += iprot->readString(this->part_vals[_i2148]); + } + xfer += iprot->readListEnd(); + } + this->__isset.part_vals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->environment_context.read(iprot); + this->__isset.environment_context = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_with_environment_context_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); + std::vector ::const_iterator _iter2149; + for (_iter2149 = this->part_vals.begin(); _iter2149 != this->part_vals.end(); ++_iter2149) + { + xfer += oprot->writeString((*_iter2149)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->environment_context.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_append_partition_with_environment_context_pargs::~ThriftHiveMetastore_append_partition_with_environment_context_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_append_partition_with_environment_context_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_with_environment_context_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); + std::vector ::const_iterator _iter2150; + for (_iter2150 = (*(this->part_vals)).begin(); _iter2150 != (*(this->part_vals)).end(); ++_iter2150) + { + xfer += oprot->writeString((*_iter2150)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += (*(this->environment_context)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_append_partition_with_environment_context_result::~ThriftHiveMetastore_append_partition_with_environment_context_result() noexcept { +} + +ThriftHiveMetastore_append_partition_with_environment_context_result::ThriftHiveMetastore_append_partition_with_environment_context_result() noexcept { +} + +uint32_t ThriftHiveMetastore_append_partition_with_environment_context_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_append_partition_with_environment_context_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_with_environment_context_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_append_partition_with_environment_context_presult::~ThriftHiveMetastore_append_partition_with_environment_context_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_append_partition_with_environment_context_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_append_partition_req_args::~ThriftHiveMetastore_append_partition_req_args() noexcept { +} + +ThriftHiveMetastore_append_partition_req_args::ThriftHiveMetastore_append_partition_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_append_partition_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->appendPartitionsReq.read(iprot); + this->__isset.appendPartitionsReq = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_append_partition_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_req_args"); + + xfer += oprot->writeFieldBegin("appendPartitionsReq", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->appendPartitionsReq.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_append_partition_req_pargs::~ThriftHiveMetastore_append_partition_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_append_partition_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_req_pargs"); + + xfer += oprot->writeFieldBegin("appendPartitionsReq", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->appendPartitionsReq)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_append_partition_req_result::~ThriftHiveMetastore_append_partition_req_result() noexcept { +} + +ThriftHiveMetastore_append_partition_req_result::ThriftHiveMetastore_append_partition_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_append_partition_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_append_partition_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_append_partition_req_presult::~ThriftHiveMetastore_append_partition_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_append_partition_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_append_partition_by_name_args::~ThriftHiveMetastore_append_partition_by_name_args() noexcept { +} + +ThriftHiveMetastore_append_partition_by_name_args::ThriftHiveMetastore_append_partition_by_name_args() noexcept + : db_name(), + tbl_name(), + part_name() { +} + +uint32_t ThriftHiveMetastore_append_partition_by_name_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->part_name); + this->__isset.part_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_append_partition_by_name_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_by_name_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->part_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_append_partition_by_name_pargs::~ThriftHiveMetastore_append_partition_by_name_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_append_partition_by_name_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_by_name_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->part_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_append_partition_by_name_result::~ThriftHiveMetastore_append_partition_by_name_result() noexcept { +} + +ThriftHiveMetastore_append_partition_by_name_result::ThriftHiveMetastore_append_partition_by_name_result() noexcept { +} + +uint32_t ThriftHiveMetastore_append_partition_by_name_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_append_partition_by_name_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_by_name_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_append_partition_by_name_presult::~ThriftHiveMetastore_append_partition_by_name_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_append_partition_by_name_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_append_partition_by_name_with_environment_context_args::~ThriftHiveMetastore_append_partition_by_name_with_environment_context_args() noexcept { +} + +ThriftHiveMetastore_append_partition_by_name_with_environment_context_args::ThriftHiveMetastore_append_partition_by_name_with_environment_context_args() noexcept + : db_name(), + tbl_name(), + part_name() { +} + +uint32_t ThriftHiveMetastore_append_partition_by_name_with_environment_context_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->part_name); + this->__isset.part_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->environment_context.read(iprot); + this->__isset.environment_context = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_append_partition_by_name_with_environment_context_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_by_name_with_environment_context_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->part_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->environment_context.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_append_partition_by_name_with_environment_context_pargs::~ThriftHiveMetastore_append_partition_by_name_with_environment_context_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_append_partition_by_name_with_environment_context_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_by_name_with_environment_context_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->part_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += (*(this->environment_context)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_append_partition_by_name_with_environment_context_result::~ThriftHiveMetastore_append_partition_by_name_with_environment_context_result() noexcept { +} + +ThriftHiveMetastore_append_partition_by_name_with_environment_context_result::ThriftHiveMetastore_append_partition_by_name_with_environment_context_result() noexcept { +} + +uint32_t ThriftHiveMetastore_append_partition_by_name_with_environment_context_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_append_partition_by_name_with_environment_context_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_by_name_with_environment_context_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_append_partition_by_name_with_environment_context_presult::~ThriftHiveMetastore_append_partition_by_name_with_environment_context_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_append_partition_by_name_with_environment_context_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_partition_args::~ThriftHiveMetastore_drop_partition_args() noexcept { +} + +ThriftHiveMetastore_drop_partition_args::ThriftHiveMetastore_drop_partition_args() noexcept + : db_name(), + tbl_name(), + deleteData(0) { +} + +uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->part_vals.clear(); + uint32_t _size2151; + ::apache::thrift::protocol::TType _etype2154; + xfer += iprot->readListBegin(_etype2154, _size2151); + this->part_vals.resize(_size2151); + uint32_t _i2155; + for (_i2155 = 0; _i2155 < _size2151; ++_i2155) + { + xfer += iprot->readString(this->part_vals[_i2155]); + } + xfer += iprot->readListEnd(); + } + this->__isset.part_vals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->deleteData); + this->__isset.deleteData = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_partition_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); + std::vector ::const_iterator _iter2156; + for (_iter2156 = this->part_vals.begin(); _iter2156 != this->part_vals.end(); ++_iter2156) + { + xfer += oprot->writeString((*_iter2156)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool(this->deleteData); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_partition_pargs::~ThriftHiveMetastore_drop_partition_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_partition_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); + std::vector ::const_iterator _iter2157; + for (_iter2157 = (*(this->part_vals)).begin(); _iter2157 != (*(this->part_vals)).end(); ++_iter2157) + { + xfer += oprot->writeString((*_iter2157)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool((*(this->deleteData))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_partition_result::~ThriftHiveMetastore_drop_partition_result() noexcept { +} + +ThriftHiveMetastore_drop_partition_result::ThriftHiveMetastore_drop_partition_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_drop_partition_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_partition_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_partition_presult::~ThriftHiveMetastore_drop_partition_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_partition_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_partition_with_environment_context_args::~ThriftHiveMetastore_drop_partition_with_environment_context_args() noexcept { +} + +ThriftHiveMetastore_drop_partition_with_environment_context_args::ThriftHiveMetastore_drop_partition_with_environment_context_args() noexcept + : db_name(), + tbl_name(), + deleteData(0) { +} + +uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->part_vals.clear(); + uint32_t _size2158; + ::apache::thrift::protocol::TType _etype2161; + xfer += iprot->readListBegin(_etype2161, _size2158); + this->part_vals.resize(_size2158); + uint32_t _i2162; + for (_i2162 = 0; _i2162 < _size2158; ++_i2162) + { + xfer += iprot->readString(this->part_vals[_i2162]); + } + xfer += iprot->readListEnd(); + } + this->__isset.part_vals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->deleteData); + this->__isset.deleteData = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->environment_context.read(iprot); + this->__isset.environment_context = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_with_environment_context_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); + std::vector ::const_iterator _iter2163; + for (_iter2163 = this->part_vals.begin(); _iter2163 != this->part_vals.end(); ++_iter2163) + { + xfer += oprot->writeString((*_iter2163)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool(this->deleteData); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 5); + xfer += this->environment_context.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_partition_with_environment_context_pargs::~ThriftHiveMetastore_drop_partition_with_environment_context_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_with_environment_context_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); + std::vector ::const_iterator _iter2164; + for (_iter2164 = (*(this->part_vals)).begin(); _iter2164 != (*(this->part_vals)).end(); ++_iter2164) + { + xfer += oprot->writeString((*_iter2164)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool((*(this->deleteData))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 5); + xfer += (*(this->environment_context)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_partition_with_environment_context_result::~ThriftHiveMetastore_drop_partition_with_environment_context_result() noexcept { +} + +ThriftHiveMetastore_drop_partition_with_environment_context_result::ThriftHiveMetastore_drop_partition_with_environment_context_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_with_environment_context_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_partition_with_environment_context_presult::~ThriftHiveMetastore_drop_partition_with_environment_context_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_partition_req_args::~ThriftHiveMetastore_drop_partition_req_args() noexcept { +} + +ThriftHiveMetastore_drop_partition_req_args::ThriftHiveMetastore_drop_partition_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_partition_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->dropPartitionReq.read(iprot); + this->__isset.dropPartitionReq = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_partition_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_req_args"); + + xfer += oprot->writeFieldBegin("dropPartitionReq", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->dropPartitionReq.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_partition_req_pargs::~ThriftHiveMetastore_drop_partition_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_partition_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_req_pargs"); + + xfer += oprot->writeFieldBegin("dropPartitionReq", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->dropPartitionReq)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_partition_req_result::~ThriftHiveMetastore_drop_partition_req_result() noexcept { +} + +ThriftHiveMetastore_drop_partition_req_result::ThriftHiveMetastore_drop_partition_req_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_drop_partition_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_partition_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_partition_req_presult::~ThriftHiveMetastore_drop_partition_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_partition_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_partition_by_name_args::~ThriftHiveMetastore_drop_partition_by_name_args() noexcept { +} + +ThriftHiveMetastore_drop_partition_by_name_args::ThriftHiveMetastore_drop_partition_by_name_args() noexcept + : db_name(), + tbl_name(), + part_name(), + deleteData(0) { +} + +uint32_t ThriftHiveMetastore_drop_partition_by_name_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->part_name); + this->__isset.part_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->deleteData); + this->__isset.deleteData = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_partition_by_name_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_by_name_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->part_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool(this->deleteData); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_partition_by_name_pargs::~ThriftHiveMetastore_drop_partition_by_name_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_partition_by_name_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_by_name_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->part_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool((*(this->deleteData))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_partition_by_name_result::~ThriftHiveMetastore_drop_partition_by_name_result() noexcept { +} + +ThriftHiveMetastore_drop_partition_by_name_result::ThriftHiveMetastore_drop_partition_by_name_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_drop_partition_by_name_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_partition_by_name_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_by_name_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_partition_by_name_presult::~ThriftHiveMetastore_drop_partition_by_name_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_partition_by_name_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args::~ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args() noexcept { +} + +ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args::ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args() noexcept + : db_name(), + tbl_name(), + part_name(), + deleteData(0) { +} + +uint32_t ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->part_name); + this->__isset.part_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->deleteData); + this->__isset.deleteData = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->environment_context.read(iprot); + this->__isset.environment_context = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->part_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool(this->deleteData); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 5); + xfer += this->environment_context.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_partition_by_name_with_environment_context_pargs::~ThriftHiveMetastore_drop_partition_by_name_with_environment_context_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_partition_by_name_with_environment_context_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_by_name_with_environment_context_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->part_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool((*(this->deleteData))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 5); + xfer += (*(this->environment_context)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result::~ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result() noexcept { +} + +ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result::ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_partition_by_name_with_environment_context_presult::~ThriftHiveMetastore_drop_partition_by_name_with_environment_context_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_partition_by_name_with_environment_context_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_partitions_req_args::~ThriftHiveMetastore_drop_partitions_req_args() noexcept { +} + +ThriftHiveMetastore_drop_partitions_req_args::ThriftHiveMetastore_drop_partitions_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_partitions_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_partitions_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partitions_req_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_partitions_req_pargs::~ThriftHiveMetastore_drop_partitions_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_partitions_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partitions_req_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_partitions_req_result::~ThriftHiveMetastore_drop_partitions_req_result() noexcept { +} + +ThriftHiveMetastore_drop_partitions_req_result::ThriftHiveMetastore_drop_partitions_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_partitions_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_partitions_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partitions_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_partitions_req_presult::~ThriftHiveMetastore_drop_partitions_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_partitions_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partition_args::~ThriftHiveMetastore_get_partition_args() noexcept { +} + +ThriftHiveMetastore_get_partition_args::ThriftHiveMetastore_get_partition_args() noexcept + : db_name(), + tbl_name() { +} + +uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->part_vals.clear(); + uint32_t _size2165; + ::apache::thrift::protocol::TType _etype2168; + xfer += iprot->readListBegin(_etype2168, _size2165); + this->part_vals.resize(_size2165); + uint32_t _i2169; + for (_i2169 = 0; _i2169 < _size2165; ++_i2169) + { + xfer += iprot->readString(this->part_vals[_i2169]); + } + xfer += iprot->readListEnd(); + } + this->__isset.part_vals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partition_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); + std::vector ::const_iterator _iter2170; + for (_iter2170 = this->part_vals.begin(); _iter2170 != this->part_vals.end(); ++_iter2170) + { + xfer += oprot->writeString((*_iter2170)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_pargs::~ThriftHiveMetastore_get_partition_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partition_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); + std::vector ::const_iterator _iter2171; + for (_iter2171 = (*(this->part_vals)).begin(); _iter2171 != (*(this->part_vals)).end(); ++_iter2171) + { + xfer += oprot->writeString((*_iter2171)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_result::~ThriftHiveMetastore_get_partition_result() noexcept { +} + +ThriftHiveMetastore_get_partition_result::ThriftHiveMetastore_get_partition_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partition_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partition_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_presult::~ThriftHiveMetastore_get_partition_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partition_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partition_req_args::~ThriftHiveMetastore_get_partition_req_args() noexcept { +} + +ThriftHiveMetastore_get_partition_req_args::ThriftHiveMetastore_get_partition_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partition_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partition_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_req_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_req_pargs::~ThriftHiveMetastore_get_partition_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partition_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_req_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_req_result::~ThriftHiveMetastore_get_partition_req_result() noexcept { +} + +ThriftHiveMetastore_get_partition_req_result::ThriftHiveMetastore_get_partition_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partition_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partition_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_req_presult::~ThriftHiveMetastore_get_partition_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partition_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_exchange_partition_args::~ThriftHiveMetastore_exchange_partition_args() noexcept { +} + +ThriftHiveMetastore_exchange_partition_args::ThriftHiveMetastore_exchange_partition_args() noexcept + : source_db(), + source_table_name(), + dest_db(), + dest_table_name() { +} + +uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->partitionSpecs.clear(); + uint32_t _size2172; + ::apache::thrift::protocol::TType _ktype2173; + ::apache::thrift::protocol::TType _vtype2174; + xfer += iprot->readMapBegin(_ktype2173, _vtype2174, _size2172); + uint32_t _i2176; + for (_i2176 = 0; _i2176 < _size2172; ++_i2176) + { + std::string _key2177; + xfer += iprot->readString(_key2177); + std::string& _val2178 = this->partitionSpecs[_key2177]; + xfer += iprot->readString(_val2178); + } + xfer += iprot->readMapEnd(); + } + this->__isset.partitionSpecs = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->source_db); + this->__isset.source_db = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->source_table_name); + this->__isset.source_table_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dest_db); + this->__isset.dest_db = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dest_table_name); + this->__isset.dest_table_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_exchange_partition_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_exchange_partition_args"); + + xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->partitionSpecs.size())); + std::map ::const_iterator _iter2179; + for (_iter2179 = this->partitionSpecs.begin(); _iter2179 != this->partitionSpecs.end(); ++_iter2179) + { + xfer += oprot->writeString(_iter2179->first); + xfer += oprot->writeString(_iter2179->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("source_db", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->source_db); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("source_table_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->source_table_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dest_db", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->dest_db); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dest_table_name", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->dest_table_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_exchange_partition_pargs::~ThriftHiveMetastore_exchange_partition_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_exchange_partition_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_exchange_partition_pargs"); + + xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->partitionSpecs)).size())); + std::map ::const_iterator _iter2180; + for (_iter2180 = (*(this->partitionSpecs)).begin(); _iter2180 != (*(this->partitionSpecs)).end(); ++_iter2180) + { + xfer += oprot->writeString(_iter2180->first); + xfer += oprot->writeString(_iter2180->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("source_db", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->source_db))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("source_table_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->source_table_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dest_db", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString((*(this->dest_db))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dest_table_name", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString((*(this->dest_table_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_exchange_partition_result::~ThriftHiveMetastore_exchange_partition_result() noexcept { +} + +ThriftHiveMetastore_exchange_partition_result::ThriftHiveMetastore_exchange_partition_result() noexcept { +} + +uint32_t ThriftHiveMetastore_exchange_partition_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_exchange_partition_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_exchange_partition_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_exchange_partition_presult::~ThriftHiveMetastore_exchange_partition_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_exchange_partition_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_exchange_partitions_args::~ThriftHiveMetastore_exchange_partitions_args() noexcept { +} + +ThriftHiveMetastore_exchange_partitions_args::ThriftHiveMetastore_exchange_partitions_args() noexcept + : source_db(), + source_table_name(), + dest_db(), + dest_table_name() { +} + +uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->partitionSpecs.clear(); + uint32_t _size2181; + ::apache::thrift::protocol::TType _ktype2182; + ::apache::thrift::protocol::TType _vtype2183; + xfer += iprot->readMapBegin(_ktype2182, _vtype2183, _size2181); + uint32_t _i2185; + for (_i2185 = 0; _i2185 < _size2181; ++_i2185) + { + std::string _key2186; + xfer += iprot->readString(_key2186); + std::string& _val2187 = this->partitionSpecs[_key2186]; + xfer += iprot->readString(_val2187); + } + xfer += iprot->readMapEnd(); + } + this->__isset.partitionSpecs = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->source_db); + this->__isset.source_db = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->source_table_name); + this->__isset.source_table_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dest_db); + this->__isset.dest_db = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dest_table_name); + this->__isset.dest_table_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_exchange_partitions_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_exchange_partitions_args"); + + xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->partitionSpecs.size())); + std::map ::const_iterator _iter2188; + for (_iter2188 = this->partitionSpecs.begin(); _iter2188 != this->partitionSpecs.end(); ++_iter2188) + { + xfer += oprot->writeString(_iter2188->first); + xfer += oprot->writeString(_iter2188->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("source_db", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->source_db); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("source_table_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->source_table_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dest_db", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->dest_db); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dest_table_name", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->dest_table_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_exchange_partitions_pargs::~ThriftHiveMetastore_exchange_partitions_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_exchange_partitions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_exchange_partitions_pargs"); + + xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->partitionSpecs)).size())); + std::map ::const_iterator _iter2189; + for (_iter2189 = (*(this->partitionSpecs)).begin(); _iter2189 != (*(this->partitionSpecs)).end(); ++_iter2189) + { + xfer += oprot->writeString(_iter2189->first); + xfer += oprot->writeString(_iter2189->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("source_db", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->source_db))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("source_table_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->source_table_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dest_db", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString((*(this->dest_db))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dest_table_name", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString((*(this->dest_table_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_exchange_partitions_result::~ThriftHiveMetastore_exchange_partitions_result() noexcept { +} + +ThriftHiveMetastore_exchange_partitions_result::ThriftHiveMetastore_exchange_partitions_result() noexcept { +} + +uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2190; + ::apache::thrift::protocol::TType _etype2193; + xfer += iprot->readListBegin(_etype2193, _size2190); + this->success.resize(_size2190); + uint32_t _i2194; + for (_i2194 = 0; _i2194 < _size2190; ++_i2194) + { + xfer += this->success[_i2194].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_exchange_partitions_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_exchange_partitions_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter2195; + for (_iter2195 = this->success.begin(); _iter2195 != this->success.end(); ++_iter2195) + { + xfer += (*_iter2195).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_exchange_partitions_presult::~ThriftHiveMetastore_exchange_partitions_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2196; + ::apache::thrift::protocol::TType _etype2199; + xfer += iprot->readListBegin(_etype2199, _size2196); + (*(this->success)).resize(_size2196); + uint32_t _i2200; + for (_i2200 = 0; _i2200 < _size2196; ++_i2200) + { + xfer += (*(this->success))[_i2200].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partition_with_auth_args::~ThriftHiveMetastore_get_partition_with_auth_args() noexcept { +} + +ThriftHiveMetastore_get_partition_with_auth_args::ThriftHiveMetastore_get_partition_with_auth_args() noexcept + : db_name(), + tbl_name(), + user_name() { +} + +uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->part_vals.clear(); + uint32_t _size2201; + ::apache::thrift::protocol::TType _etype2204; + xfer += iprot->readListBegin(_etype2204, _size2201); + this->part_vals.resize(_size2201); + uint32_t _i2205; + for (_i2205 = 0; _i2205 < _size2201; ++_i2205) + { + xfer += iprot->readString(this->part_vals[_i2205]); + } + xfer += iprot->readListEnd(); + } + this->__isset.part_vals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->user_name); + this->__isset.user_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->group_names.clear(); + uint32_t _size2206; + ::apache::thrift::protocol::TType _etype2209; + xfer += iprot->readListBegin(_etype2209, _size2206); + this->group_names.resize(_size2206); + uint32_t _i2210; + for (_i2210 = 0; _i2210 < _size2206; ++_i2210) + { + xfer += iprot->readString(this->group_names[_i2210]); + } + xfer += iprot->readListEnd(); + } + this->__isset.group_names = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partition_with_auth_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_with_auth_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); + std::vector ::const_iterator _iter2211; + for (_iter2211 = this->part_vals.begin(); _iter2211 != this->part_vals.end(); ++_iter2211) + { + xfer += oprot->writeString((*_iter2211)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->user_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); + std::vector ::const_iterator _iter2212; + for (_iter2212 = this->group_names.begin(); _iter2212 != this->group_names.end(); ++_iter2212) + { + xfer += oprot->writeString((*_iter2212)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_with_auth_pargs::~ThriftHiveMetastore_get_partition_with_auth_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partition_with_auth_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_with_auth_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); + std::vector ::const_iterator _iter2213; + for (_iter2213 = (*(this->part_vals)).begin(); _iter2213 != (*(this->part_vals)).end(); ++_iter2213) + { + xfer += oprot->writeString((*_iter2213)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString((*(this->user_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); + std::vector ::const_iterator _iter2214; + for (_iter2214 = (*(this->group_names)).begin(); _iter2214 != (*(this->group_names)).end(); ++_iter2214) + { + xfer += oprot->writeString((*_iter2214)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_with_auth_result::~ThriftHiveMetastore_get_partition_with_auth_result() noexcept { +} + +ThriftHiveMetastore_get_partition_with_auth_result::ThriftHiveMetastore_get_partition_with_auth_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partition_with_auth_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partition_with_auth_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_with_auth_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_with_auth_presult::~ThriftHiveMetastore_get_partition_with_auth_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partition_with_auth_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partition_by_name_args::~ThriftHiveMetastore_get_partition_by_name_args() noexcept { +} + +ThriftHiveMetastore_get_partition_by_name_args::ThriftHiveMetastore_get_partition_by_name_args() noexcept + : db_name(), + tbl_name(), + part_name() { +} + +uint32_t ThriftHiveMetastore_get_partition_by_name_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->part_name); + this->__isset.part_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partition_by_name_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_by_name_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->part_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_by_name_pargs::~ThriftHiveMetastore_get_partition_by_name_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partition_by_name_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_by_name_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->part_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_by_name_result::~ThriftHiveMetastore_get_partition_by_name_result() noexcept { +} + +ThriftHiveMetastore_get_partition_by_name_result::ThriftHiveMetastore_get_partition_by_name_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partition_by_name_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partition_by_name_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_by_name_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_by_name_presult::~ThriftHiveMetastore_get_partition_by_name_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partition_by_name_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partitions_args::~ThriftHiveMetastore_get_partitions_args() noexcept { +} + +ThriftHiveMetastore_get_partitions_args::ThriftHiveMetastore_get_partitions_args() noexcept + : db_name(), + tbl_name(), + max_parts(-1) { +} + +uint32_t ThriftHiveMetastore_get_partitions_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I16) { + xfer += iprot->readI16(this->max_parts); + this->__isset.max_parts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I16, 3); + xfer += oprot->writeI16(this->max_parts); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_pargs::~ThriftHiveMetastore_get_partitions_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I16, 3); + xfer += oprot->writeI16((*(this->max_parts))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_result::~ThriftHiveMetastore_get_partitions_result() noexcept { +} + +ThriftHiveMetastore_get_partitions_result::ThriftHiveMetastore_get_partitions_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2215; + ::apache::thrift::protocol::TType _etype2218; + xfer += iprot->readListBegin(_etype2218, _size2215); + this->success.resize(_size2215); + uint32_t _i2219; + for (_i2219 = 0; _i2219 < _size2215; ++_i2219) + { + xfer += this->success[_i2219].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter2220; + for (_iter2220 = this->success.begin(); _iter2220 != this->success.end(); ++_iter2220) + { + xfer += (*_iter2220).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_presult::~ThriftHiveMetastore_get_partitions_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2221; + ::apache::thrift::protocol::TType _etype2224; + xfer += iprot->readListBegin(_etype2224, _size2221); + (*(this->success)).resize(_size2221); + uint32_t _i2225; + for (_i2225 = 0; _i2225 < _size2221; ++_i2225) + { + xfer += (*(this->success))[_i2225].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partitions_req_args::~ThriftHiveMetastore_get_partitions_req_args() noexcept { +} + +ThriftHiveMetastore_get_partitions_req_args::ThriftHiveMetastore_get_partitions_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partitions_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_req_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_req_pargs::~ThriftHiveMetastore_get_partitions_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_req_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_req_result::~ThriftHiveMetastore_get_partitions_req_result() noexcept { +} + +ThriftHiveMetastore_get_partitions_req_result::ThriftHiveMetastore_get_partitions_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partitions_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_req_presult::~ThriftHiveMetastore_get_partitions_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partitions_with_auth_args::~ThriftHiveMetastore_get_partitions_with_auth_args() noexcept { +} + +ThriftHiveMetastore_get_partitions_with_auth_args::ThriftHiveMetastore_get_partitions_with_auth_args() noexcept + : db_name(), + tbl_name(), + max_parts(-1), + user_name() { +} + +uint32_t ThriftHiveMetastore_get_partitions_with_auth_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I16) { + xfer += iprot->readI16(this->max_parts); + this->__isset.max_parts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->user_name); + this->__isset.user_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->group_names.clear(); + uint32_t _size2226; + ::apache::thrift::protocol::TType _etype2229; + xfer += iprot->readListBegin(_etype2229, _size2226); + this->group_names.resize(_size2226); + uint32_t _i2230; + for (_i2230 = 0; _i2230 < _size2226; ++_i2230) + { + xfer += iprot->readString(this->group_names[_i2230]); + } + xfer += iprot->readListEnd(); + } + this->__isset.group_names = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_with_auth_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_with_auth_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I16, 3); + xfer += oprot->writeI16(this->max_parts); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->user_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); + std::vector ::const_iterator _iter2231; + for (_iter2231 = this->group_names.begin(); _iter2231 != this->group_names.end(); ++_iter2231) + { + xfer += oprot->writeString((*_iter2231)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_with_auth_pargs::~ThriftHiveMetastore_get_partitions_with_auth_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_with_auth_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_with_auth_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I16, 3); + xfer += oprot->writeI16((*(this->max_parts))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString((*(this->user_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); + std::vector ::const_iterator _iter2232; + for (_iter2232 = (*(this->group_names)).begin(); _iter2232 != (*(this->group_names)).end(); ++_iter2232) + { + xfer += oprot->writeString((*_iter2232)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_with_auth_result::~ThriftHiveMetastore_get_partitions_with_auth_result() noexcept { +} + +ThriftHiveMetastore_get_partitions_with_auth_result::ThriftHiveMetastore_get_partitions_with_auth_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2233; + ::apache::thrift::protocol::TType _etype2236; + xfer += iprot->readListBegin(_etype2236, _size2233); + this->success.resize(_size2233); + uint32_t _i2237; + for (_i2237 = 0; _i2237 < _size2233; ++_i2237) + { + xfer += this->success[_i2237].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_with_auth_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter2238; + for (_iter2238 = this->success.begin(); _iter2238 != this->success.end(); ++_iter2238) + { + xfer += (*_iter2238).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_with_auth_presult::~ThriftHiveMetastore_get_partitions_with_auth_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2239; + ::apache::thrift::protocol::TType _etype2242; + xfer += iprot->readListBegin(_etype2242, _size2239); + (*(this->success)).resize(_size2239); + uint32_t _i2243; + for (_i2243 = 0; _i2243 < _size2239; ++_i2243) + { + xfer += (*(this->success))[_i2243].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partitions_pspec_args::~ThriftHiveMetastore_get_partitions_pspec_args() noexcept { +} + +ThriftHiveMetastore_get_partitions_pspec_args::ThriftHiveMetastore_get_partitions_pspec_args() noexcept + : db_name(), + tbl_name(), + max_parts(-1) { +} + +uint32_t ThriftHiveMetastore_get_partitions_pspec_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->max_parts); + this->__isset.max_parts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_pspec_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_pspec_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32(this->max_parts); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_pspec_pargs::~ThriftHiveMetastore_get_partitions_pspec_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_pspec_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_pspec_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32((*(this->max_parts))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_pspec_result::~ThriftHiveMetastore_get_partitions_pspec_result() noexcept { +} + +ThriftHiveMetastore_get_partitions_pspec_result::ThriftHiveMetastore_get_partitions_pspec_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2244; + ::apache::thrift::protocol::TType _etype2247; + xfer += iprot->readListBegin(_etype2247, _size2244); + this->success.resize(_size2244); + uint32_t _i2248; + for (_i2248 = 0; _i2248 < _size2244; ++_i2248) + { + xfer += this->success[_i2248].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_pspec_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_pspec_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter2249; + for (_iter2249 = this->success.begin(); _iter2249 != this->success.end(); ++_iter2249) + { + xfer += (*_iter2249).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_pspec_presult::~ThriftHiveMetastore_get_partitions_pspec_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2250; + ::apache::thrift::protocol::TType _etype2253; + xfer += iprot->readListBegin(_etype2253, _size2250); + (*(this->success)).resize(_size2250); + uint32_t _i2254; + for (_i2254 = 0; _i2254 < _size2250; ++_i2254) + { + xfer += (*(this->success))[_i2254].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partition_names_args::~ThriftHiveMetastore_get_partition_names_args() noexcept { +} + +ThriftHiveMetastore_get_partition_names_args::ThriftHiveMetastore_get_partition_names_args() noexcept + : db_name(), + tbl_name(), + max_parts(-1) { +} + +uint32_t ThriftHiveMetastore_get_partition_names_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I16) { + xfer += iprot->readI16(this->max_parts); + this->__isset.max_parts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partition_names_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_names_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I16, 3); + xfer += oprot->writeI16(this->max_parts); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_names_pargs::~ThriftHiveMetastore_get_partition_names_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partition_names_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_names_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I16, 3); + xfer += oprot->writeI16((*(this->max_parts))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_names_result::~ThriftHiveMetastore_get_partition_names_result() noexcept { +} + +ThriftHiveMetastore_get_partition_names_result::ThriftHiveMetastore_get_partition_names_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2255; + ::apache::thrift::protocol::TType _etype2258; + xfer += iprot->readListBegin(_etype2258, _size2255); + this->success.resize(_size2255); + uint32_t _i2259; + for (_i2259 = 0; _i2259 < _size2255; ++_i2259) + { + xfer += iprot->readString(this->success[_i2259]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partition_names_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_names_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::vector ::const_iterator _iter2260; + for (_iter2260 = this->success.begin(); _iter2260 != this->success.end(); ++_iter2260) + { + xfer += oprot->writeString((*_iter2260)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_names_presult::~ThriftHiveMetastore_get_partition_names_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2261; + ::apache::thrift::protocol::TType _etype2264; + xfer += iprot->readListBegin(_etype2264, _size2261); + (*(this->success)).resize(_size2261); + uint32_t _i2265; + for (_i2265 = 0; _i2265 < _size2261; ++_i2265) + { + xfer += iprot->readString((*(this->success))[_i2265]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_fetch_partition_names_req_args::~ThriftHiveMetastore_fetch_partition_names_req_args() noexcept { +} + +ThriftHiveMetastore_fetch_partition_names_req_args::ThriftHiveMetastore_fetch_partition_names_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_fetch_partition_names_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->partitionReq.read(iprot); + this->__isset.partitionReq = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_fetch_partition_names_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_fetch_partition_names_req_args"); + + xfer += oprot->writeFieldBegin("partitionReq", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->partitionReq.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_fetch_partition_names_req_pargs::~ThriftHiveMetastore_fetch_partition_names_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_fetch_partition_names_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_fetch_partition_names_req_pargs"); + + xfer += oprot->writeFieldBegin("partitionReq", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->partitionReq)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_fetch_partition_names_req_result::~ThriftHiveMetastore_fetch_partition_names_req_result() noexcept { +} + +ThriftHiveMetastore_fetch_partition_names_req_result::ThriftHiveMetastore_fetch_partition_names_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_fetch_partition_names_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2266; + ::apache::thrift::protocol::TType _etype2269; + xfer += iprot->readListBegin(_etype2269, _size2266); + this->success.resize(_size2266); + uint32_t _i2270; + for (_i2270 = 0; _i2270 < _size2266; ++_i2270) + { + xfer += iprot->readString(this->success[_i2270]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_fetch_partition_names_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_fetch_partition_names_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::vector ::const_iterator _iter2271; + for (_iter2271 = this->success.begin(); _iter2271 != this->success.end(); ++_iter2271) + { + xfer += oprot->writeString((*_iter2271)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_fetch_partition_names_req_presult::~ThriftHiveMetastore_fetch_partition_names_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_fetch_partition_names_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2272; + ::apache::thrift::protocol::TType _etype2275; + xfer += iprot->readListBegin(_etype2275, _size2272); + (*(this->success)).resize(_size2272); + uint32_t _i2276; + for (_i2276 = 0; _i2276 < _size2272; ++_i2276) + { + xfer += iprot->readString((*(this->success))[_i2276]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partition_values_args::~ThriftHiveMetastore_get_partition_values_args() noexcept { +} + +ThriftHiveMetastore_get_partition_values_args::ThriftHiveMetastore_get_partition_values_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partition_values_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partition_values_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_values_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_values_pargs::~ThriftHiveMetastore_get_partition_values_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partition_values_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_values_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_values_result::~ThriftHiveMetastore_get_partition_values_result() noexcept { +} + +ThriftHiveMetastore_get_partition_values_result::ThriftHiveMetastore_get_partition_values_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partition_values_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partition_values_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_values_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_values_presult::~ThriftHiveMetastore_get_partition_values_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partition_values_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partitions_ps_args::~ThriftHiveMetastore_get_partitions_ps_args() noexcept { +} + +ThriftHiveMetastore_get_partitions_ps_args::ThriftHiveMetastore_get_partitions_ps_args() noexcept + : db_name(), + tbl_name(), + max_parts(-1) { +} + +uint32_t ThriftHiveMetastore_get_partitions_ps_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->part_vals.clear(); + uint32_t _size2277; + ::apache::thrift::protocol::TType _etype2280; + xfer += iprot->readListBegin(_etype2280, _size2277); + this->part_vals.resize(_size2277); + uint32_t _i2281; + for (_i2281 = 0; _i2281 < _size2277; ++_i2281) + { + xfer += iprot->readString(this->part_vals[_i2281]); + } + xfer += iprot->readListEnd(); + } + this->__isset.part_vals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I16) { + xfer += iprot->readI16(this->max_parts); + this->__isset.max_parts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_ps_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_ps_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); + std::vector ::const_iterator _iter2282; + for (_iter2282 = this->part_vals.begin(); _iter2282 != this->part_vals.end(); ++_iter2282) + { + xfer += oprot->writeString((*_iter2282)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I16, 4); + xfer += oprot->writeI16(this->max_parts); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_ps_pargs::~ThriftHiveMetastore_get_partitions_ps_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_ps_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_ps_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); + std::vector ::const_iterator _iter2283; + for (_iter2283 = (*(this->part_vals)).begin(); _iter2283 != (*(this->part_vals)).end(); ++_iter2283) + { + xfer += oprot->writeString((*_iter2283)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I16, 4); + xfer += oprot->writeI16((*(this->max_parts))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_ps_result::~ThriftHiveMetastore_get_partitions_ps_result() noexcept { +} + +ThriftHiveMetastore_get_partitions_ps_result::ThriftHiveMetastore_get_partitions_ps_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2284; + ::apache::thrift::protocol::TType _etype2287; + xfer += iprot->readListBegin(_etype2287, _size2284); + this->success.resize(_size2284); + uint32_t _i2288; + for (_i2288 = 0; _i2288 < _size2284; ++_i2288) + { + xfer += this->success[_i2288].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_ps_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_ps_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter2289; + for (_iter2289 = this->success.begin(); _iter2289 != this->success.end(); ++_iter2289) + { + xfer += (*_iter2289).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_ps_presult::~ThriftHiveMetastore_get_partitions_ps_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2290; + ::apache::thrift::protocol::TType _etype2293; + xfer += iprot->readListBegin(_etype2293, _size2290); + (*(this->success)).resize(_size2290); + uint32_t _i2294; + for (_i2294 = 0; _i2294 < _size2290; ++_i2294) + { + xfer += (*(this->success))[_i2294].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partitions_ps_with_auth_args::~ThriftHiveMetastore_get_partitions_ps_with_auth_args() noexcept { +} + +ThriftHiveMetastore_get_partitions_ps_with_auth_args::ThriftHiveMetastore_get_partitions_ps_with_auth_args() noexcept + : db_name(), + tbl_name(), + max_parts(-1), + user_name() { +} + +uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->part_vals.clear(); + uint32_t _size2295; + ::apache::thrift::protocol::TType _etype2298; + xfer += iprot->readListBegin(_etype2298, _size2295); + this->part_vals.resize(_size2295); + uint32_t _i2299; + for (_i2299 = 0; _i2299 < _size2295; ++_i2299) + { + xfer += iprot->readString(this->part_vals[_i2299]); + } + xfer += iprot->readListEnd(); + } + this->__isset.part_vals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I16) { + xfer += iprot->readI16(this->max_parts); + this->__isset.max_parts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->user_name); + this->__isset.user_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->group_names.clear(); + uint32_t _size2300; + ::apache::thrift::protocol::TType _etype2303; + xfer += iprot->readListBegin(_etype2303, _size2300); + this->group_names.resize(_size2300); + uint32_t _i2304; + for (_i2304 = 0; _i2304 < _size2300; ++_i2304) + { + xfer += iprot->readString(this->group_names[_i2304]); + } + xfer += iprot->readListEnd(); + } + this->__isset.group_names = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_ps_with_auth_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); + std::vector ::const_iterator _iter2305; + for (_iter2305 = this->part_vals.begin(); _iter2305 != this->part_vals.end(); ++_iter2305) + { + xfer += oprot->writeString((*_iter2305)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I16, 4); + xfer += oprot->writeI16(this->max_parts); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->user_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); + std::vector ::const_iterator _iter2306; + for (_iter2306 = this->group_names.begin(); _iter2306 != this->group_names.end(); ++_iter2306) + { + xfer += oprot->writeString((*_iter2306)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::~ThriftHiveMetastore_get_partitions_ps_with_auth_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_ps_with_auth_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); + std::vector ::const_iterator _iter2307; + for (_iter2307 = (*(this->part_vals)).begin(); _iter2307 != (*(this->part_vals)).end(); ++_iter2307) + { + xfer += oprot->writeString((*_iter2307)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I16, 4); + xfer += oprot->writeI16((*(this->max_parts))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString((*(this->user_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); + std::vector ::const_iterator _iter2308; + for (_iter2308 = (*(this->group_names)).begin(); _iter2308 != (*(this->group_names)).end(); ++_iter2308) + { + xfer += oprot->writeString((*_iter2308)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_ps_with_auth_result::~ThriftHiveMetastore_get_partitions_ps_with_auth_result() noexcept { +} + +ThriftHiveMetastore_get_partitions_ps_with_auth_result::ThriftHiveMetastore_get_partitions_ps_with_auth_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2309; + ::apache::thrift::protocol::TType _etype2312; + xfer += iprot->readListBegin(_etype2312, _size2309); + this->success.resize(_size2309); + uint32_t _i2313; + for (_i2313 = 0; _i2313 < _size2309; ++_i2313) + { + xfer += this->success[_i2313].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_ps_with_auth_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter2314; + for (_iter2314 = this->success.begin(); _iter2314 != this->success.end(); ++_iter2314) + { + xfer += (*_iter2314).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_ps_with_auth_presult::~ThriftHiveMetastore_get_partitions_ps_with_auth_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2315; + ::apache::thrift::protocol::TType _etype2318; + xfer += iprot->readListBegin(_etype2318, _size2315); + (*(this->success)).resize(_size2315); + uint32_t _i2319; + for (_i2319 = 0; _i2319 < _size2315; ++_i2319) + { + xfer += (*(this->success))[_i2319].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partitions_ps_with_auth_req_args::~ThriftHiveMetastore_get_partitions_ps_with_auth_req_args() noexcept { +} + +ThriftHiveMetastore_get_partitions_ps_with_auth_req_args::ThriftHiveMetastore_get_partitions_ps_with_auth_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_ps_with_auth_req_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_ps_with_auth_req_pargs::~ThriftHiveMetastore_get_partitions_ps_with_auth_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_ps_with_auth_req_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_ps_with_auth_req_result::~ThriftHiveMetastore_get_partitions_ps_with_auth_req_result() noexcept { +} + +ThriftHiveMetastore_get_partitions_ps_with_auth_req_result::ThriftHiveMetastore_get_partitions_ps_with_auth_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_ps_with_auth_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_ps_with_auth_req_presult::~ThriftHiveMetastore_get_partitions_ps_with_auth_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partition_names_ps_args::~ThriftHiveMetastore_get_partition_names_ps_args() noexcept { +} + +ThriftHiveMetastore_get_partition_names_ps_args::ThriftHiveMetastore_get_partition_names_ps_args() noexcept + : db_name(), + tbl_name(), + max_parts(-1) { +} + +uint32_t ThriftHiveMetastore_get_partition_names_ps_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->part_vals.clear(); + uint32_t _size2320; + ::apache::thrift::protocol::TType _etype2323; + xfer += iprot->readListBegin(_etype2323, _size2320); + this->part_vals.resize(_size2320); + uint32_t _i2324; + for (_i2324 = 0; _i2324 < _size2320; ++_i2324) + { + xfer += iprot->readString(this->part_vals[_i2324]); + } + xfer += iprot->readListEnd(); + } + this->__isset.part_vals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I16) { + xfer += iprot->readI16(this->max_parts); + this->__isset.max_parts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partition_names_ps_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_names_ps_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); + std::vector ::const_iterator _iter2325; + for (_iter2325 = this->part_vals.begin(); _iter2325 != this->part_vals.end(); ++_iter2325) + { + xfer += oprot->writeString((*_iter2325)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I16, 4); + xfer += oprot->writeI16(this->max_parts); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_names_ps_pargs::~ThriftHiveMetastore_get_partition_names_ps_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partition_names_ps_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_names_ps_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); + std::vector ::const_iterator _iter2326; + for (_iter2326 = (*(this->part_vals)).begin(); _iter2326 != (*(this->part_vals)).end(); ++_iter2326) + { + xfer += oprot->writeString((*_iter2326)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I16, 4); + xfer += oprot->writeI16((*(this->max_parts))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_names_ps_result::~ThriftHiveMetastore_get_partition_names_ps_result() noexcept { +} + +ThriftHiveMetastore_get_partition_names_ps_result::ThriftHiveMetastore_get_partition_names_ps_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2327; + ::apache::thrift::protocol::TType _etype2330; + xfer += iprot->readListBegin(_etype2330, _size2327); + this->success.resize(_size2327); + uint32_t _i2331; + for (_i2331 = 0; _i2331 < _size2327; ++_i2331) + { + xfer += iprot->readString(this->success[_i2331]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partition_names_ps_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_names_ps_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::vector ::const_iterator _iter2332; + for (_iter2332 = this->success.begin(); _iter2332 != this->success.end(); ++_iter2332) + { + xfer += oprot->writeString((*_iter2332)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_names_ps_presult::~ThriftHiveMetastore_get_partition_names_ps_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2333; + ::apache::thrift::protocol::TType _etype2336; + xfer += iprot->readListBegin(_etype2336, _size2333); + (*(this->success)).resize(_size2333); + uint32_t _i2337; + for (_i2337 = 0; _i2337 < _size2333; ++_i2337) + { + xfer += iprot->readString((*(this->success))[_i2337]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partition_names_ps_req_args::~ThriftHiveMetastore_get_partition_names_ps_req_args() noexcept { +} + +ThriftHiveMetastore_get_partition_names_ps_req_args::ThriftHiveMetastore_get_partition_names_ps_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partition_names_ps_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partition_names_ps_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_names_ps_req_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_names_ps_req_pargs::~ThriftHiveMetastore_get_partition_names_ps_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partition_names_ps_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_names_ps_req_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_names_ps_req_result::~ThriftHiveMetastore_get_partition_names_ps_req_result() noexcept { +} + +ThriftHiveMetastore_get_partition_names_ps_req_result::ThriftHiveMetastore_get_partition_names_ps_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partition_names_ps_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partition_names_ps_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_names_ps_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_names_ps_req_presult::~ThriftHiveMetastore_get_partition_names_ps_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partition_names_ps_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partition_names_req_args::~ThriftHiveMetastore_get_partition_names_req_args() noexcept { +} + +ThriftHiveMetastore_get_partition_names_req_args::ThriftHiveMetastore_get_partition_names_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partition_names_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partition_names_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_names_req_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_names_req_pargs::~ThriftHiveMetastore_get_partition_names_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partition_names_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_names_req_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_names_req_result::~ThriftHiveMetastore_get_partition_names_req_result() noexcept { +} + +ThriftHiveMetastore_get_partition_names_req_result::ThriftHiveMetastore_get_partition_names_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partition_names_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2338; + ::apache::thrift::protocol::TType _etype2341; + xfer += iprot->readListBegin(_etype2341, _size2338); + this->success.resize(_size2338); + uint32_t _i2342; + for (_i2342 = 0; _i2342 < _size2338; ++_i2342) + { + xfer += iprot->readString(this->success[_i2342]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partition_names_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_names_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::vector ::const_iterator _iter2343; + for (_iter2343 = this->success.begin(); _iter2343 != this->success.end(); ++_iter2343) + { + xfer += oprot->writeString((*_iter2343)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_names_req_presult::~ThriftHiveMetastore_get_partition_names_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partition_names_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2344; + ::apache::thrift::protocol::TType _etype2347; + xfer += iprot->readListBegin(_etype2347, _size2344); + (*(this->success)).resize(_size2344); + uint32_t _i2348; + for (_i2348 = 0; _i2348 < _size2344; ++_i2348) + { + xfer += iprot->readString((*(this->success))[_i2348]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partitions_by_filter_args::~ThriftHiveMetastore_get_partitions_by_filter_args() noexcept { +} + +ThriftHiveMetastore_get_partitions_by_filter_args::ThriftHiveMetastore_get_partitions_by_filter_args() noexcept + : db_name(), + tbl_name(), + filter(), + max_parts(-1) { +} + +uint32_t ThriftHiveMetastore_get_partitions_by_filter_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->filter); + this->__isset.filter = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I16) { + xfer += iprot->readI16(this->max_parts); + this->__isset.max_parts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_by_filter_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_filter_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("filter", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->filter); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I16, 4); + xfer += oprot->writeI16(this->max_parts); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_by_filter_pargs::~ThriftHiveMetastore_get_partitions_by_filter_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_by_filter_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_filter_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("filter", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->filter))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I16, 4); + xfer += oprot->writeI16((*(this->max_parts))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_by_filter_result::~ThriftHiveMetastore_get_partitions_by_filter_result() noexcept { +} + +ThriftHiveMetastore_get_partitions_by_filter_result::ThriftHiveMetastore_get_partitions_by_filter_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2349; + ::apache::thrift::protocol::TType _etype2352; + xfer += iprot->readListBegin(_etype2352, _size2349); + this->success.resize(_size2349); + uint32_t _i2353; + for (_i2353 = 0; _i2353 < _size2349; ++_i2353) + { + xfer += this->success[_i2353].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_filter_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter2354; + for (_iter2354 = this->success.begin(); _iter2354 != this->success.end(); ++_iter2354) + { + xfer += (*_iter2354).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_by_filter_presult::~ThriftHiveMetastore_get_partitions_by_filter_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2355; + ::apache::thrift::protocol::TType _etype2358; + xfer += iprot->readListBegin(_etype2358, _size2355); + (*(this->success)).resize(_size2355); + uint32_t _i2359; + for (_i2359 = 0; _i2359 < _size2355; ++_i2359) + { + xfer += (*(this->success))[_i2359].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partitions_by_filter_req_args::~ThriftHiveMetastore_get_partitions_by_filter_req_args() noexcept { +} + +ThriftHiveMetastore_get_partitions_by_filter_req_args::ThriftHiveMetastore_get_partitions_by_filter_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partitions_by_filter_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_by_filter_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_filter_req_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_by_filter_req_pargs::~ThriftHiveMetastore_get_partitions_by_filter_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_by_filter_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_filter_req_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_by_filter_req_result::~ThriftHiveMetastore_get_partitions_by_filter_req_result() noexcept { +} + +ThriftHiveMetastore_get_partitions_by_filter_req_result::ThriftHiveMetastore_get_partitions_by_filter_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partitions_by_filter_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2360; + ::apache::thrift::protocol::TType _etype2363; + xfer += iprot->readListBegin(_etype2363, _size2360); + this->success.resize(_size2360); + uint32_t _i2364; + for (_i2364 = 0; _i2364 < _size2360; ++_i2364) + { + xfer += this->success[_i2364].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_by_filter_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_filter_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter2365; + for (_iter2365 = this->success.begin(); _iter2365 != this->success.end(); ++_iter2365) + { + xfer += (*_iter2365).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_by_filter_req_presult::~ThriftHiveMetastore_get_partitions_by_filter_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_by_filter_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2366; + ::apache::thrift::protocol::TType _etype2369; + xfer += iprot->readListBegin(_etype2369, _size2366); + (*(this->success)).resize(_size2366); + uint32_t _i2370; + for (_i2370 = 0; _i2370 < _size2366; ++_i2370) + { + xfer += (*(this->success))[_i2370].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_part_specs_by_filter_args::~ThriftHiveMetastore_get_part_specs_by_filter_args() noexcept { +} + +ThriftHiveMetastore_get_part_specs_by_filter_args::ThriftHiveMetastore_get_part_specs_by_filter_args() noexcept + : db_name(), + tbl_name(), + filter(), + max_parts(-1) { +} + +uint32_t ThriftHiveMetastore_get_part_specs_by_filter_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->filter); + this->__isset.filter = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->max_parts); + this->__isset.max_parts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_part_specs_by_filter_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_part_specs_by_filter_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("filter", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->filter); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32(this->max_parts); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_part_specs_by_filter_pargs::~ThriftHiveMetastore_get_part_specs_by_filter_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_part_specs_by_filter_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_part_specs_by_filter_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("filter", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->filter))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32((*(this->max_parts))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_part_specs_by_filter_result::~ThriftHiveMetastore_get_part_specs_by_filter_result() noexcept { +} + +ThriftHiveMetastore_get_part_specs_by_filter_result::ThriftHiveMetastore_get_part_specs_by_filter_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2371; + ::apache::thrift::protocol::TType _etype2374; + xfer += iprot->readListBegin(_etype2374, _size2371); + this->success.resize(_size2371); + uint32_t _i2375; + for (_i2375 = 0; _i2375 < _size2371; ++_i2375) + { + xfer += this->success[_i2375].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_part_specs_by_filter_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter2376; + for (_iter2376 = this->success.begin(); _iter2376 != this->success.end(); ++_iter2376) + { + xfer += (*_iter2376).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_part_specs_by_filter_presult::~ThriftHiveMetastore_get_part_specs_by_filter_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_part_specs_by_filter_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2377; + ::apache::thrift::protocol::TType _etype2380; + xfer += iprot->readListBegin(_etype2380, _size2377); + (*(this->success)).resize(_size2377); + uint32_t _i2381; + for (_i2381 = 0; _i2381 < _size2377; ++_i2381) + { + xfer += (*(this->success))[_i2381].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partitions_by_expr_args::~ThriftHiveMetastore_get_partitions_by_expr_args() noexcept { +} + +ThriftHiveMetastore_get_partitions_by_expr_args::ThriftHiveMetastore_get_partitions_by_expr_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partitions_by_expr_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_by_expr_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_expr_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_by_expr_pargs::~ThriftHiveMetastore_get_partitions_by_expr_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_by_expr_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_expr_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_by_expr_result::~ThriftHiveMetastore_get_partitions_by_expr_result() noexcept { +} + +ThriftHiveMetastore_get_partitions_by_expr_result::ThriftHiveMetastore_get_partitions_by_expr_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partitions_by_expr_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_by_expr_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_expr_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_by_expr_presult::~ThriftHiveMetastore_get_partitions_by_expr_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_by_expr_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partitions_spec_by_expr_args::~ThriftHiveMetastore_get_partitions_spec_by_expr_args() noexcept { +} + +ThriftHiveMetastore_get_partitions_spec_by_expr_args::ThriftHiveMetastore_get_partitions_spec_by_expr_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partitions_spec_by_expr_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_spec_by_expr_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_spec_by_expr_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_spec_by_expr_pargs::~ThriftHiveMetastore_get_partitions_spec_by_expr_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_spec_by_expr_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_spec_by_expr_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_spec_by_expr_result::~ThriftHiveMetastore_get_partitions_spec_by_expr_result() noexcept { +} + +ThriftHiveMetastore_get_partitions_spec_by_expr_result::ThriftHiveMetastore_get_partitions_spec_by_expr_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partitions_spec_by_expr_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_spec_by_expr_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_spec_by_expr_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_spec_by_expr_presult::~ThriftHiveMetastore_get_partitions_spec_by_expr_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_spec_by_expr_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_num_partitions_by_filter_args::~ThriftHiveMetastore_get_num_partitions_by_filter_args() noexcept { +} + +ThriftHiveMetastore_get_num_partitions_by_filter_args::ThriftHiveMetastore_get_num_partitions_by_filter_args() noexcept + : db_name(), + tbl_name(), + filter() { +} + +uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->filter); + this->__isset.filter = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_num_partitions_by_filter_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("filter", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->filter); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_num_partitions_by_filter_pargs::~ThriftHiveMetastore_get_num_partitions_by_filter_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_num_partitions_by_filter_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("filter", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->filter))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_num_partitions_by_filter_result::~ThriftHiveMetastore_get_num_partitions_by_filter_result() noexcept { +} + +ThriftHiveMetastore_get_num_partitions_by_filter_result::ThriftHiveMetastore_get_num_partitions_by_filter_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_num_partitions_by_filter_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0); + xfer += oprot->writeI32(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_num_partitions_by_filter_presult::~ThriftHiveMetastore_get_num_partitions_by_filter_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partitions_by_names_args::~ThriftHiveMetastore_get_partitions_by_names_args() noexcept { +} + +ThriftHiveMetastore_get_partitions_by_names_args::ThriftHiveMetastore_get_partitions_by_names_args() noexcept + : db_name(), + tbl_name() { +} + +uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->names.clear(); + uint32_t _size2382; + ::apache::thrift::protocol::TType _etype2385; + xfer += iprot->readListBegin(_etype2385, _size2382); + this->names.resize(_size2382); + uint32_t _i2386; + for (_i2386 = 0; _i2386 < _size2382; ++_i2386) + { + xfer += iprot->readString(this->names[_i2386]); + } + xfer += iprot->readListEnd(); + } + this->__isset.names = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_by_names_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_names_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->names.size())); + std::vector ::const_iterator _iter2387; + for (_iter2387 = this->names.begin(); _iter2387 != this->names.end(); ++_iter2387) + { + xfer += oprot->writeString((*_iter2387)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_by_names_pargs::~ThriftHiveMetastore_get_partitions_by_names_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_by_names_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_names_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->names)).size())); + std::vector ::const_iterator _iter2388; + for (_iter2388 = (*(this->names)).begin(); _iter2388 != (*(this->names)).end(); ++_iter2388) + { + xfer += oprot->writeString((*_iter2388)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_by_names_result::~ThriftHiveMetastore_get_partitions_by_names_result() noexcept { +} + +ThriftHiveMetastore_get_partitions_by_names_result::ThriftHiveMetastore_get_partitions_by_names_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2389; + ::apache::thrift::protocol::TType _etype2392; + xfer += iprot->readListBegin(_etype2392, _size2389); + this->success.resize(_size2389); + uint32_t _i2393; + for (_i2393 = 0; _i2393 < _size2389; ++_i2393) + { + xfer += this->success[_i2393].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_by_names_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_names_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter2394; + for (_iter2394 = this->success.begin(); _iter2394 != this->success.end(); ++_iter2394) + { + xfer += (*_iter2394).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_by_names_presult::~ThriftHiveMetastore_get_partitions_by_names_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_by_names_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2395; + ::apache::thrift::protocol::TType _etype2398; + xfer += iprot->readListBegin(_etype2398, _size2395); + (*(this->success)).resize(_size2395); + uint32_t _i2399; + for (_i2399 = 0; _i2399 < _size2395; ++_i2399) + { + xfer += (*(this->success))[_i2399].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partitions_by_names_req_args::~ThriftHiveMetastore_get_partitions_by_names_req_args() noexcept { +} + +ThriftHiveMetastore_get_partitions_by_names_req_args::ThriftHiveMetastore_get_partitions_by_names_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partitions_by_names_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_by_names_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_names_req_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_by_names_req_pargs::~ThriftHiveMetastore_get_partitions_by_names_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_by_names_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_names_req_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_by_names_req_result::~ThriftHiveMetastore_get_partitions_by_names_req_result() noexcept { +} + +ThriftHiveMetastore_get_partitions_by_names_req_result::ThriftHiveMetastore_get_partitions_by_names_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partitions_by_names_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_by_names_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_names_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_by_names_req_presult::~ThriftHiveMetastore_get_partitions_by_names_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_by_names_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_properties_args::~ThriftHiveMetastore_get_properties_args() noexcept { +} + +ThriftHiveMetastore_get_properties_args::ThriftHiveMetastore_get_properties_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_properties_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_properties_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_properties_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_properties_pargs::~ThriftHiveMetastore_get_properties_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_properties_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_properties_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_properties_result::~ThriftHiveMetastore_get_properties_result() noexcept { +} + +ThriftHiveMetastore_get_properties_result::ThriftHiveMetastore_get_properties_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_properties_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->e1.read(iprot); + this->__isset.e1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->e2.read(iprot); + this->__isset.e2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_properties_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_properties_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.e1) { + xfer += oprot->writeFieldBegin("e1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->e1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.e2) { + xfer += oprot->writeFieldBegin("e2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->e2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_properties_presult::~ThriftHiveMetastore_get_properties_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_properties_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->e1.read(iprot); + this->__isset.e1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->e2.read(iprot); + this->__isset.e2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_set_properties_args::~ThriftHiveMetastore_set_properties_args() noexcept { +} + +ThriftHiveMetastore_set_properties_args::ThriftHiveMetastore_set_properties_args() noexcept { +} + +uint32_t ThriftHiveMetastore_set_properties_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_set_properties_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_set_properties_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_set_properties_pargs::~ThriftHiveMetastore_set_properties_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_set_properties_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_set_properties_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_set_properties_result::~ThriftHiveMetastore_set_properties_result() noexcept { +} + +ThriftHiveMetastore_set_properties_result::ThriftHiveMetastore_set_properties_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_set_properties_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->e1.read(iprot); + this->__isset.e1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->e2.read(iprot); + this->__isset.e2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_set_properties_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_set_properties_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.e1) { + xfer += oprot->writeFieldBegin("e1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->e1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.e2) { + xfer += oprot->writeFieldBegin("e2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->e2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_set_properties_presult::~ThriftHiveMetastore_set_properties_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_set_properties_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->e1.read(iprot); + this->__isset.e1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->e2.read(iprot); + this->__isset.e2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_alter_partition_args::~ThriftHiveMetastore_alter_partition_args() noexcept { +} + +ThriftHiveMetastore_alter_partition_args::ThriftHiveMetastore_alter_partition_args() noexcept + : db_name(), + tbl_name() { +} + +uint32_t ThriftHiveMetastore_alter_partition_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->new_part.read(iprot); + this->__isset.new_part = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_partition_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_partition_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("new_part", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->new_part.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_partition_pargs::~ThriftHiveMetastore_alter_partition_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_partition_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_partition_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("new_part", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += (*(this->new_part)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_partition_result::~ThriftHiveMetastore_alter_partition_result() noexcept { +} + +ThriftHiveMetastore_alter_partition_result::ThriftHiveMetastore_alter_partition_result() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_partition_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_partition_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_partition_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_partition_presult::~ThriftHiveMetastore_alter_partition_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_partition_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_alter_partitions_args::~ThriftHiveMetastore_alter_partitions_args() noexcept { +} + +ThriftHiveMetastore_alter_partitions_args::ThriftHiveMetastore_alter_partitions_args() noexcept + : db_name(), + tbl_name() { +} + +uint32_t ThriftHiveMetastore_alter_partitions_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->new_parts.clear(); + uint32_t _size2400; + ::apache::thrift::protocol::TType _etype2403; + xfer += iprot->readListBegin(_etype2403, _size2400); + this->new_parts.resize(_size2400); + uint32_t _i2404; + for (_i2404 = 0; _i2404 < _size2400; ++_i2404) + { + xfer += this->new_parts[_i2404].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.new_parts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_partitions_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_partitions_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); + std::vector ::const_iterator _iter2405; + for (_iter2405 = this->new_parts.begin(); _iter2405 != this->new_parts.end(); ++_iter2405) + { + xfer += (*_iter2405).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_partitions_pargs::~ThriftHiveMetastore_alter_partitions_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_partitions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_partitions_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); + std::vector ::const_iterator _iter2406; + for (_iter2406 = (*(this->new_parts)).begin(); _iter2406 != (*(this->new_parts)).end(); ++_iter2406) + { + xfer += (*_iter2406).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_partitions_result::~ThriftHiveMetastore_alter_partitions_result() noexcept { +} + +ThriftHiveMetastore_alter_partitions_result::ThriftHiveMetastore_alter_partitions_result() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_partitions_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_partitions_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_partitions_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_partitions_presult::~ThriftHiveMetastore_alter_partitions_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_partitions_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_alter_partitions_with_environment_context_args::~ThriftHiveMetastore_alter_partitions_with_environment_context_args() noexcept { +} + +ThriftHiveMetastore_alter_partitions_with_environment_context_args::ThriftHiveMetastore_alter_partitions_with_environment_context_args() noexcept + : db_name(), + tbl_name() { +} + +uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->new_parts.clear(); + uint32_t _size2407; + ::apache::thrift::protocol::TType _etype2410; + xfer += iprot->readListBegin(_etype2410, _size2407); + this->new_parts.resize(_size2407); + uint32_t _i2411; + for (_i2411 = 0; _i2411 < _size2407; ++_i2411) + { + xfer += this->new_parts[_i2411].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.new_parts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->environment_context.read(iprot); + this->__isset.environment_context = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_partitions_with_environment_context_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); + std::vector ::const_iterator _iter2412; + for (_iter2412 = this->new_parts.begin(); _iter2412 != this->new_parts.end(); ++_iter2412) + { + xfer += (*_iter2412).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->environment_context.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_partitions_with_environment_context_pargs::~ThriftHiveMetastore_alter_partitions_with_environment_context_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_partitions_with_environment_context_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); + std::vector ::const_iterator _iter2413; + for (_iter2413 = (*(this->new_parts)).begin(); _iter2413 != (*(this->new_parts)).end(); ++_iter2413) + { + xfer += (*_iter2413).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += (*(this->environment_context)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_partitions_with_environment_context_result::~ThriftHiveMetastore_alter_partitions_with_environment_context_result() noexcept { +} + +ThriftHiveMetastore_alter_partitions_with_environment_context_result::ThriftHiveMetastore_alter_partitions_with_environment_context_result() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_partitions_with_environment_context_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_partitions_with_environment_context_presult::~ThriftHiveMetastore_alter_partitions_with_environment_context_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_alter_partitions_req_args::~ThriftHiveMetastore_alter_partitions_req_args() noexcept { +} + +ThriftHiveMetastore_alter_partitions_req_args::ThriftHiveMetastore_alter_partitions_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_partitions_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_partitions_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_partitions_req_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_partitions_req_pargs::~ThriftHiveMetastore_alter_partitions_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_partitions_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_partitions_req_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_partitions_req_result::~ThriftHiveMetastore_alter_partitions_req_result() noexcept { +} + +ThriftHiveMetastore_alter_partitions_req_result::ThriftHiveMetastore_alter_partitions_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_partitions_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_partitions_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_partitions_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_partitions_req_presult::~ThriftHiveMetastore_alter_partitions_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_partitions_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_alter_partition_with_environment_context_args::~ThriftHiveMetastore_alter_partition_with_environment_context_args() noexcept { +} + +ThriftHiveMetastore_alter_partition_with_environment_context_args::ThriftHiveMetastore_alter_partition_with_environment_context_args() noexcept + : db_name(), + tbl_name() { +} + +uint32_t ThriftHiveMetastore_alter_partition_with_environment_context_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->new_part.read(iprot); + this->__isset.new_part = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->environment_context.read(iprot); + this->__isset.environment_context = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_partition_with_environment_context_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_partition_with_environment_context_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("new_part", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->new_part.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->environment_context.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_partition_with_environment_context_pargs::~ThriftHiveMetastore_alter_partition_with_environment_context_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_partition_with_environment_context_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_partition_with_environment_context_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("new_part", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += (*(this->new_part)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += (*(this->environment_context)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_partition_with_environment_context_result::~ThriftHiveMetastore_alter_partition_with_environment_context_result() noexcept { +} + +ThriftHiveMetastore_alter_partition_with_environment_context_result::ThriftHiveMetastore_alter_partition_with_environment_context_result() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_partition_with_environment_context_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_partition_with_environment_context_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_partition_with_environment_context_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_partition_with_environment_context_presult::~ThriftHiveMetastore_alter_partition_with_environment_context_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_partition_with_environment_context_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_rename_partition_args::~ThriftHiveMetastore_rename_partition_args() noexcept { +} + +ThriftHiveMetastore_rename_partition_args::ThriftHiveMetastore_rename_partition_args() noexcept + : db_name(), + tbl_name() { +} + +uint32_t ThriftHiveMetastore_rename_partition_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->part_vals.clear(); + uint32_t _size2414; + ::apache::thrift::protocol::TType _etype2417; + xfer += iprot->readListBegin(_etype2417, _size2414); + this->part_vals.resize(_size2414); + uint32_t _i2418; + for (_i2418 = 0; _i2418 < _size2414; ++_i2418) + { + xfer += iprot->readString(this->part_vals[_i2418]); + } + xfer += iprot->readListEnd(); + } + this->__isset.part_vals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->new_part.read(iprot); + this->__isset.new_part = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_rename_partition_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_rename_partition_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); + std::vector ::const_iterator _iter2419; + for (_iter2419 = this->part_vals.begin(); _iter2419 != this->part_vals.end(); ++_iter2419) + { + xfer += oprot->writeString((*_iter2419)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("new_part", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->new_part.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_rename_partition_pargs::~ThriftHiveMetastore_rename_partition_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_rename_partition_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_rename_partition_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); + std::vector ::const_iterator _iter2420; + for (_iter2420 = (*(this->part_vals)).begin(); _iter2420 != (*(this->part_vals)).end(); ++_iter2420) + { + xfer += oprot->writeString((*_iter2420)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("new_part", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += (*(this->new_part)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_rename_partition_result::~ThriftHiveMetastore_rename_partition_result() noexcept { +} + +ThriftHiveMetastore_rename_partition_result::ThriftHiveMetastore_rename_partition_result() noexcept { +} + +uint32_t ThriftHiveMetastore_rename_partition_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_rename_partition_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_rename_partition_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_rename_partition_presult::~ThriftHiveMetastore_rename_partition_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_rename_partition_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_rename_partition_req_args::~ThriftHiveMetastore_rename_partition_req_args() noexcept { +} + +ThriftHiveMetastore_rename_partition_req_args::ThriftHiveMetastore_rename_partition_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_rename_partition_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_rename_partition_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_rename_partition_req_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_rename_partition_req_pargs::~ThriftHiveMetastore_rename_partition_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_rename_partition_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_rename_partition_req_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_rename_partition_req_result::~ThriftHiveMetastore_rename_partition_req_result() noexcept { +} + +ThriftHiveMetastore_rename_partition_req_result::ThriftHiveMetastore_rename_partition_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_rename_partition_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_rename_partition_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_rename_partition_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_rename_partition_req_presult::~ThriftHiveMetastore_rename_partition_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_rename_partition_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_partition_name_has_valid_characters_args::~ThriftHiveMetastore_partition_name_has_valid_characters_args() noexcept { +} + +ThriftHiveMetastore_partition_name_has_valid_characters_args::ThriftHiveMetastore_partition_name_has_valid_characters_args() noexcept + : throw_exception(0) { +} + +uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->part_vals.clear(); + uint32_t _size2421; + ::apache::thrift::protocol::TType _etype2424; + xfer += iprot->readListBegin(_etype2424, _size2421); + this->part_vals.resize(_size2421); + uint32_t _i2425; + for (_i2425 = 0; _i2425 < _size2421; ++_i2425) + { + xfer += iprot->readString(this->part_vals[_i2425]); + } + xfer += iprot->readListEnd(); + } + this->__isset.part_vals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->throw_exception); + this->__isset.throw_exception = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_partition_name_has_valid_characters_args"); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); + std::vector ::const_iterator _iter2426; + for (_iter2426 = this->part_vals.begin(); _iter2426 != this->part_vals.end(); ++_iter2426) + { + xfer += oprot->writeString((*_iter2426)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("throw_exception", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool(this->throw_exception); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_partition_name_has_valid_characters_pargs::~ThriftHiveMetastore_partition_name_has_valid_characters_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_partition_name_has_valid_characters_pargs"); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); + std::vector ::const_iterator _iter2427; + for (_iter2427 = (*(this->part_vals)).begin(); _iter2427 != (*(this->part_vals)).end(); ++_iter2427) + { + xfer += oprot->writeString((*_iter2427)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("throw_exception", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool((*(this->throw_exception))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_partition_name_has_valid_characters_result::~ThriftHiveMetastore_partition_name_has_valid_characters_result() noexcept { +} + +ThriftHiveMetastore_partition_name_has_valid_characters_result::ThriftHiveMetastore_partition_name_has_valid_characters_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_partition_name_has_valid_characters_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_partition_name_has_valid_characters_presult::~ThriftHiveMetastore_partition_name_has_valid_characters_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_config_value_args::~ThriftHiveMetastore_get_config_value_args() noexcept { +} + +ThriftHiveMetastore_get_config_value_args::ThriftHiveMetastore_get_config_value_args() noexcept + : name(), + defaultValue() { +} + +uint32_t ThriftHiveMetastore_get_config_value_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->defaultValue); + this->__isset.defaultValue = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_config_value_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_config_value_args"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("defaultValue", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->defaultValue); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_config_value_pargs::~ThriftHiveMetastore_get_config_value_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_config_value_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_config_value_pargs"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("defaultValue", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->defaultValue))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_config_value_result::~ThriftHiveMetastore_get_config_value_result() noexcept { +} + +ThriftHiveMetastore_get_config_value_result::ThriftHiveMetastore_get_config_value_result() noexcept + : success() { +} + +uint32_t ThriftHiveMetastore_get_config_value_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_config_value_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_config_value_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0); + xfer += oprot->writeString(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_config_value_presult::~ThriftHiveMetastore_get_config_value_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_config_value_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_partition_name_to_vals_args::~ThriftHiveMetastore_partition_name_to_vals_args() noexcept { +} + +ThriftHiveMetastore_partition_name_to_vals_args::ThriftHiveMetastore_partition_name_to_vals_args() noexcept + : part_name() { +} + +uint32_t ThriftHiveMetastore_partition_name_to_vals_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->part_name); + this->__isset.part_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_partition_name_to_vals_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_partition_name_to_vals_args"); + + xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->part_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_partition_name_to_vals_pargs::~ThriftHiveMetastore_partition_name_to_vals_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_partition_name_to_vals_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_partition_name_to_vals_pargs"); + + xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->part_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_partition_name_to_vals_result::~ThriftHiveMetastore_partition_name_to_vals_result() noexcept { +} + +ThriftHiveMetastore_partition_name_to_vals_result::ThriftHiveMetastore_partition_name_to_vals_result() noexcept { +} + +uint32_t ThriftHiveMetastore_partition_name_to_vals_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2428; + ::apache::thrift::protocol::TType _etype2431; + xfer += iprot->readListBegin(_etype2431, _size2428); + this->success.resize(_size2428); + uint32_t _i2432; + for (_i2432 = 0; _i2432 < _size2428; ++_i2432) + { + xfer += iprot->readString(this->success[_i2432]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_partition_name_to_vals_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_partition_name_to_vals_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::vector ::const_iterator _iter2433; + for (_iter2433 = this->success.begin(); _iter2433 != this->success.end(); ++_iter2433) + { + xfer += oprot->writeString((*_iter2433)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_partition_name_to_vals_presult::~ThriftHiveMetastore_partition_name_to_vals_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_partition_name_to_vals_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2434; + ::apache::thrift::protocol::TType _etype2437; + xfer += iprot->readListBegin(_etype2437, _size2434); + (*(this->success)).resize(_size2434); + uint32_t _i2438; + for (_i2438 = 0; _i2438 < _size2434; ++_i2438) + { + xfer += iprot->readString((*(this->success))[_i2438]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_partition_name_to_spec_args::~ThriftHiveMetastore_partition_name_to_spec_args() noexcept { +} + +ThriftHiveMetastore_partition_name_to_spec_args::ThriftHiveMetastore_partition_name_to_spec_args() noexcept + : part_name() { +} + +uint32_t ThriftHiveMetastore_partition_name_to_spec_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->part_name); + this->__isset.part_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_partition_name_to_spec_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_partition_name_to_spec_args"); + + xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->part_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_partition_name_to_spec_pargs::~ThriftHiveMetastore_partition_name_to_spec_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_partition_name_to_spec_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_partition_name_to_spec_pargs"); + + xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->part_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_partition_name_to_spec_result::~ThriftHiveMetastore_partition_name_to_spec_result() noexcept { +} + +ThriftHiveMetastore_partition_name_to_spec_result::ThriftHiveMetastore_partition_name_to_spec_result() noexcept { +} + +uint32_t ThriftHiveMetastore_partition_name_to_spec_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->success.clear(); + uint32_t _size2439; + ::apache::thrift::protocol::TType _ktype2440; + ::apache::thrift::protocol::TType _vtype2441; + xfer += iprot->readMapBegin(_ktype2440, _vtype2441, _size2439); + uint32_t _i2443; + for (_i2443 = 0; _i2443 < _size2439; ++_i2443) + { + std::string _key2444; + xfer += iprot->readString(_key2444); + std::string& _val2445 = this->success[_key2444]; + xfer += iprot->readString(_val2445); + } + xfer += iprot->readMapEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_partition_name_to_spec_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_partition_name_to_spec_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::map ::const_iterator _iter2446; + for (_iter2446 = this->success.begin(); _iter2446 != this->success.end(); ++_iter2446) + { + xfer += oprot->writeString(_iter2446->first); + xfer += oprot->writeString(_iter2446->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_partition_name_to_spec_presult::~ThriftHiveMetastore_partition_name_to_spec_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_partition_name_to_spec_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + (*(this->success)).clear(); + uint32_t _size2447; + ::apache::thrift::protocol::TType _ktype2448; + ::apache::thrift::protocol::TType _vtype2449; + xfer += iprot->readMapBegin(_ktype2448, _vtype2449, _size2447); + uint32_t _i2451; + for (_i2451 = 0; _i2451 < _size2447; ++_i2451) + { + std::string _key2452; + xfer += iprot->readString(_key2452); + std::string& _val2453 = (*(this->success))[_key2452]; + xfer += iprot->readString(_val2453); + } + xfer += iprot->readMapEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_markPartitionForEvent_args::~ThriftHiveMetastore_markPartitionForEvent_args() noexcept { +} + +ThriftHiveMetastore_markPartitionForEvent_args::ThriftHiveMetastore_markPartitionForEvent_args() noexcept + : db_name(), + tbl_name(), + eventType(static_cast(0)) { +} + +uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->part_vals.clear(); + uint32_t _size2454; + ::apache::thrift::protocol::TType _ktype2455; + ::apache::thrift::protocol::TType _vtype2456; + xfer += iprot->readMapBegin(_ktype2455, _vtype2456, _size2454); + uint32_t _i2458; + for (_i2458 = 0; _i2458 < _size2454; ++_i2458) + { + std::string _key2459; + xfer += iprot->readString(_key2459); + std::string& _val2460 = this->part_vals[_key2459]; + xfer += iprot->readString(_val2460); + } + xfer += iprot->readMapEnd(); + } + this->__isset.part_vals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast2461; + xfer += iprot->readI32(ecast2461); + this->eventType = static_cast(ecast2461); + this->__isset.eventType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_markPartitionForEvent_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_markPartitionForEvent_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); + std::map ::const_iterator _iter2462; + for (_iter2462 = this->part_vals.begin(); _iter2462 != this->part_vals.end(); ++_iter2462) + { + xfer += oprot->writeString(_iter2462->first); + xfer += oprot->writeString(_iter2462->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("eventType", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32(static_cast(this->eventType)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_markPartitionForEvent_pargs::~ThriftHiveMetastore_markPartitionForEvent_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_markPartitionForEvent_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_markPartitionForEvent_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); + std::map ::const_iterator _iter2463; + for (_iter2463 = (*(this->part_vals)).begin(); _iter2463 != (*(this->part_vals)).end(); ++_iter2463) + { + xfer += oprot->writeString(_iter2463->first); + xfer += oprot->writeString(_iter2463->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("eventType", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32(static_cast((*(this->eventType)))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_markPartitionForEvent_result::~ThriftHiveMetastore_markPartitionForEvent_result() noexcept { +} + +ThriftHiveMetastore_markPartitionForEvent_result::ThriftHiveMetastore_markPartitionForEvent_result() noexcept { +} + +uint32_t ThriftHiveMetastore_markPartitionForEvent_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o5.read(iprot); + this->__isset.o5 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o6.read(iprot); + this->__isset.o6 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_markPartitionForEvent_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_markPartitionForEvent_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o5) { + xfer += oprot->writeFieldBegin("o5", ::apache::thrift::protocol::T_STRUCT, 5); + xfer += this->o5.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o6) { + xfer += oprot->writeFieldBegin("o6", ::apache::thrift::protocol::T_STRUCT, 6); + xfer += this->o6.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_markPartitionForEvent_presult::~ThriftHiveMetastore_markPartitionForEvent_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_markPartitionForEvent_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o5.read(iprot); + this->__isset.o5 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o6.read(iprot); + this->__isset.o6 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_isPartitionMarkedForEvent_args::~ThriftHiveMetastore_isPartitionMarkedForEvent_args() noexcept { +} + +ThriftHiveMetastore_isPartitionMarkedForEvent_args::ThriftHiveMetastore_isPartitionMarkedForEvent_args() noexcept + : db_name(), + tbl_name(), + eventType(static_cast(0)) { +} + +uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->part_vals.clear(); + uint32_t _size2464; + ::apache::thrift::protocol::TType _ktype2465; + ::apache::thrift::protocol::TType _vtype2466; + xfer += iprot->readMapBegin(_ktype2465, _vtype2466, _size2464); + uint32_t _i2468; + for (_i2468 = 0; _i2468 < _size2464; ++_i2468) + { + std::string _key2469; + xfer += iprot->readString(_key2469); + std::string& _val2470 = this->part_vals[_key2469]; + xfer += iprot->readString(_val2470); + } + xfer += iprot->readMapEnd(); + } + this->__isset.part_vals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast2471; + xfer += iprot->readI32(ecast2471); + this->eventType = static_cast(ecast2471); + this->__isset.eventType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_isPartitionMarkedForEvent_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); + std::map ::const_iterator _iter2472; + for (_iter2472 = this->part_vals.begin(); _iter2472 != this->part_vals.end(); ++_iter2472) + { + xfer += oprot->writeString(_iter2472->first); + xfer += oprot->writeString(_iter2472->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("eventType", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32(static_cast(this->eventType)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_isPartitionMarkedForEvent_pargs::~ThriftHiveMetastore_isPartitionMarkedForEvent_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_isPartitionMarkedForEvent_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); + std::map ::const_iterator _iter2473; + for (_iter2473 = (*(this->part_vals)).begin(); _iter2473 != (*(this->part_vals)).end(); ++_iter2473) + { + xfer += oprot->writeString(_iter2473->first); + xfer += oprot->writeString(_iter2473->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("eventType", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32(static_cast((*(this->eventType)))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_isPartitionMarkedForEvent_result::~ThriftHiveMetastore_isPartitionMarkedForEvent_result() noexcept { +} + +ThriftHiveMetastore_isPartitionMarkedForEvent_result::ThriftHiveMetastore_isPartitionMarkedForEvent_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o5.read(iprot); + this->__isset.o5 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o6.read(iprot); + this->__isset.o6 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_isPartitionMarkedForEvent_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o5) { + xfer += oprot->writeFieldBegin("o5", ::apache::thrift::protocol::T_STRUCT, 5); + xfer += this->o5.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o6) { + xfer += oprot->writeFieldBegin("o6", ::apache::thrift::protocol::T_STRUCT, 6); + xfer += this->o6.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_isPartitionMarkedForEvent_presult::~ThriftHiveMetastore_isPartitionMarkedForEvent_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o5.read(iprot); + this->__isset.o5 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o6.read(iprot); + this->__isset.o6 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_primary_keys_args::~ThriftHiveMetastore_get_primary_keys_args() noexcept { +} + +ThriftHiveMetastore_get_primary_keys_args::ThriftHiveMetastore_get_primary_keys_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_primary_keys_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_primary_keys_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_primary_keys_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_primary_keys_pargs::~ThriftHiveMetastore_get_primary_keys_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_primary_keys_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_primary_keys_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_primary_keys_result::~ThriftHiveMetastore_get_primary_keys_result() noexcept { +} + +ThriftHiveMetastore_get_primary_keys_result::ThriftHiveMetastore_get_primary_keys_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_primary_keys_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_primary_keys_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_primary_keys_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_primary_keys_presult::~ThriftHiveMetastore_get_primary_keys_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_primary_keys_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_foreign_keys_args::~ThriftHiveMetastore_get_foreign_keys_args() noexcept { +} + +ThriftHiveMetastore_get_foreign_keys_args::ThriftHiveMetastore_get_foreign_keys_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_foreign_keys_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_foreign_keys_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_foreign_keys_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_foreign_keys_pargs::~ThriftHiveMetastore_get_foreign_keys_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_foreign_keys_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_foreign_keys_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_foreign_keys_result::~ThriftHiveMetastore_get_foreign_keys_result() noexcept { +} + +ThriftHiveMetastore_get_foreign_keys_result::ThriftHiveMetastore_get_foreign_keys_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_foreign_keys_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_foreign_keys_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_foreign_keys_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_foreign_keys_presult::~ThriftHiveMetastore_get_foreign_keys_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_foreign_keys_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_unique_constraints_args::~ThriftHiveMetastore_get_unique_constraints_args() noexcept { +} + +ThriftHiveMetastore_get_unique_constraints_args::ThriftHiveMetastore_get_unique_constraints_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_unique_constraints_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_unique_constraints_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_unique_constraints_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_unique_constraints_pargs::~ThriftHiveMetastore_get_unique_constraints_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_unique_constraints_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_unique_constraints_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_unique_constraints_result::~ThriftHiveMetastore_get_unique_constraints_result() noexcept { +} + +ThriftHiveMetastore_get_unique_constraints_result::ThriftHiveMetastore_get_unique_constraints_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_unique_constraints_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_unique_constraints_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_unique_constraints_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_unique_constraints_presult::~ThriftHiveMetastore_get_unique_constraints_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_unique_constraints_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_not_null_constraints_args::~ThriftHiveMetastore_get_not_null_constraints_args() noexcept { +} + +ThriftHiveMetastore_get_not_null_constraints_args::ThriftHiveMetastore_get_not_null_constraints_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_not_null_constraints_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_not_null_constraints_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_not_null_constraints_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_not_null_constraints_pargs::~ThriftHiveMetastore_get_not_null_constraints_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_not_null_constraints_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_not_null_constraints_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_not_null_constraints_result::~ThriftHiveMetastore_get_not_null_constraints_result() noexcept { +} + +ThriftHiveMetastore_get_not_null_constraints_result::ThriftHiveMetastore_get_not_null_constraints_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_not_null_constraints_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_not_null_constraints_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_not_null_constraints_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_not_null_constraints_presult::~ThriftHiveMetastore_get_not_null_constraints_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_not_null_constraints_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_default_constraints_args::~ThriftHiveMetastore_get_default_constraints_args() noexcept { +} + +ThriftHiveMetastore_get_default_constraints_args::ThriftHiveMetastore_get_default_constraints_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_default_constraints_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_default_constraints_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_default_constraints_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_default_constraints_pargs::~ThriftHiveMetastore_get_default_constraints_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_default_constraints_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_default_constraints_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_default_constraints_result::~ThriftHiveMetastore_get_default_constraints_result() noexcept { +} + +ThriftHiveMetastore_get_default_constraints_result::ThriftHiveMetastore_get_default_constraints_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_default_constraints_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_default_constraints_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_default_constraints_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_default_constraints_presult::~ThriftHiveMetastore_get_default_constraints_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_default_constraints_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_check_constraints_args::~ThriftHiveMetastore_get_check_constraints_args() noexcept { +} + +ThriftHiveMetastore_get_check_constraints_args::ThriftHiveMetastore_get_check_constraints_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_check_constraints_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_check_constraints_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_check_constraints_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_check_constraints_pargs::~ThriftHiveMetastore_get_check_constraints_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_check_constraints_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_check_constraints_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_check_constraints_result::~ThriftHiveMetastore_get_check_constraints_result() noexcept { +} + +ThriftHiveMetastore_get_check_constraints_result::ThriftHiveMetastore_get_check_constraints_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_check_constraints_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_check_constraints_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_check_constraints_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_check_constraints_presult::~ThriftHiveMetastore_get_check_constraints_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_check_constraints_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_all_table_constraints_args::~ThriftHiveMetastore_get_all_table_constraints_args() noexcept { +} + +ThriftHiveMetastore_get_all_table_constraints_args::ThriftHiveMetastore_get_all_table_constraints_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_all_table_constraints_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_all_table_constraints_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_table_constraints_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_table_constraints_pargs::~ThriftHiveMetastore_get_all_table_constraints_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_all_table_constraints_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_table_constraints_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_table_constraints_result::~ThriftHiveMetastore_get_all_table_constraints_result() noexcept { +} + +ThriftHiveMetastore_get_all_table_constraints_result::ThriftHiveMetastore_get_all_table_constraints_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_all_table_constraints_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_all_table_constraints_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_table_constraints_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_table_constraints_presult::~ThriftHiveMetastore_get_all_table_constraints_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_all_table_constraints_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_update_table_column_statistics_args::~ThriftHiveMetastore_update_table_column_statistics_args() noexcept { +} + +ThriftHiveMetastore_update_table_column_statistics_args::ThriftHiveMetastore_update_table_column_statistics_args() noexcept { +} + +uint32_t ThriftHiveMetastore_update_table_column_statistics_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->stats_obj.read(iprot); + this->__isset.stats_obj = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_update_table_column_statistics_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_table_column_statistics_args"); + + xfer += oprot->writeFieldBegin("stats_obj", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->stats_obj.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_table_column_statistics_pargs::~ThriftHiveMetastore_update_table_column_statistics_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_update_table_column_statistics_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_table_column_statistics_pargs"); + + xfer += oprot->writeFieldBegin("stats_obj", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->stats_obj)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_table_column_statistics_result::~ThriftHiveMetastore_update_table_column_statistics_result() noexcept { +} + +ThriftHiveMetastore_update_table_column_statistics_result::ThriftHiveMetastore_update_table_column_statistics_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_update_table_column_statistics_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_update_table_column_statistics_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_table_column_statistics_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_table_column_statistics_presult::~ThriftHiveMetastore_update_table_column_statistics_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_update_table_column_statistics_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_update_partition_column_statistics_args::~ThriftHiveMetastore_update_partition_column_statistics_args() noexcept { +} + +ThriftHiveMetastore_update_partition_column_statistics_args::ThriftHiveMetastore_update_partition_column_statistics_args() noexcept { +} + +uint32_t ThriftHiveMetastore_update_partition_column_statistics_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->stats_obj.read(iprot); + this->__isset.stats_obj = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_update_partition_column_statistics_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_partition_column_statistics_args"); + + xfer += oprot->writeFieldBegin("stats_obj", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->stats_obj.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_partition_column_statistics_pargs::~ThriftHiveMetastore_update_partition_column_statistics_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_update_partition_column_statistics_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_partition_column_statistics_pargs"); + + xfer += oprot->writeFieldBegin("stats_obj", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->stats_obj)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_partition_column_statistics_result::~ThriftHiveMetastore_update_partition_column_statistics_result() noexcept { +} + +ThriftHiveMetastore_update_partition_column_statistics_result::ThriftHiveMetastore_update_partition_column_statistics_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_update_partition_column_statistics_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_update_partition_column_statistics_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_partition_column_statistics_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_partition_column_statistics_presult::~ThriftHiveMetastore_update_partition_column_statistics_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_update_partition_column_statistics_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_update_table_column_statistics_req_args::~ThriftHiveMetastore_update_table_column_statistics_req_args() noexcept { +} + +ThriftHiveMetastore_update_table_column_statistics_req_args::ThriftHiveMetastore_update_table_column_statistics_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_update_table_column_statistics_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_update_table_column_statistics_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_table_column_statistics_req_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_table_column_statistics_req_pargs::~ThriftHiveMetastore_update_table_column_statistics_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_update_table_column_statistics_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_table_column_statistics_req_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_table_column_statistics_req_result::~ThriftHiveMetastore_update_table_column_statistics_req_result() noexcept { +} + +ThriftHiveMetastore_update_table_column_statistics_req_result::ThriftHiveMetastore_update_table_column_statistics_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_update_table_column_statistics_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_update_table_column_statistics_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_table_column_statistics_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_table_column_statistics_req_presult::~ThriftHiveMetastore_update_table_column_statistics_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_update_table_column_statistics_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_update_partition_column_statistics_req_args::~ThriftHiveMetastore_update_partition_column_statistics_req_args() noexcept { +} + +ThriftHiveMetastore_update_partition_column_statistics_req_args::ThriftHiveMetastore_update_partition_column_statistics_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_update_partition_column_statistics_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_update_partition_column_statistics_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_partition_column_statistics_req_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_partition_column_statistics_req_pargs::~ThriftHiveMetastore_update_partition_column_statistics_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_update_partition_column_statistics_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_partition_column_statistics_req_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_partition_column_statistics_req_result::~ThriftHiveMetastore_update_partition_column_statistics_req_result() noexcept { +} + +ThriftHiveMetastore_update_partition_column_statistics_req_result::ThriftHiveMetastore_update_partition_column_statistics_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_update_partition_column_statistics_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_update_partition_column_statistics_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_partition_column_statistics_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_partition_column_statistics_req_presult::~ThriftHiveMetastore_update_partition_column_statistics_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_update_partition_column_statistics_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_update_transaction_statistics_args::~ThriftHiveMetastore_update_transaction_statistics_args() noexcept { +} + +ThriftHiveMetastore_update_transaction_statistics_args::ThriftHiveMetastore_update_transaction_statistics_args() noexcept { +} + +uint32_t ThriftHiveMetastore_update_transaction_statistics_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_update_transaction_statistics_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_transaction_statistics_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_transaction_statistics_pargs::~ThriftHiveMetastore_update_transaction_statistics_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_update_transaction_statistics_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_transaction_statistics_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_transaction_statistics_result::~ThriftHiveMetastore_update_transaction_statistics_result() noexcept { +} + +ThriftHiveMetastore_update_transaction_statistics_result::ThriftHiveMetastore_update_transaction_statistics_result() noexcept { +} + +uint32_t ThriftHiveMetastore_update_transaction_statistics_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_update_transaction_statistics_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_transaction_statistics_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_transaction_statistics_presult::~ThriftHiveMetastore_update_transaction_statistics_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_update_transaction_statistics_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_table_column_statistics_args::~ThriftHiveMetastore_get_table_column_statistics_args() noexcept { +} + +ThriftHiveMetastore_get_table_column_statistics_args::ThriftHiveMetastore_get_table_column_statistics_args() noexcept + : db_name(), + tbl_name(), + col_name() { +} + +uint32_t ThriftHiveMetastore_get_table_column_statistics_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->col_name); + this->__isset.col_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_table_column_statistics_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_table_column_statistics_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("col_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->col_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_table_column_statistics_pargs::~ThriftHiveMetastore_get_table_column_statistics_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_table_column_statistics_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_table_column_statistics_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("col_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->col_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_table_column_statistics_result::~ThriftHiveMetastore_get_table_column_statistics_result() noexcept { +} + +ThriftHiveMetastore_get_table_column_statistics_result::ThriftHiveMetastore_get_table_column_statistics_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_table_column_statistics_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_table_column_statistics_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_table_column_statistics_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_table_column_statistics_presult::~ThriftHiveMetastore_get_table_column_statistics_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_table_column_statistics_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partition_column_statistics_args::~ThriftHiveMetastore_get_partition_column_statistics_args() noexcept { +} + +ThriftHiveMetastore_get_partition_column_statistics_args::ThriftHiveMetastore_get_partition_column_statistics_args() noexcept + : db_name(), + tbl_name(), + part_name(), + col_name() { +} + +uint32_t ThriftHiveMetastore_get_partition_column_statistics_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->part_name); + this->__isset.part_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->col_name); + this->__isset.col_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partition_column_statistics_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_column_statistics_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->part_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("col_name", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->col_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_column_statistics_pargs::~ThriftHiveMetastore_get_partition_column_statistics_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partition_column_statistics_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_column_statistics_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->part_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("col_name", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString((*(this->col_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_column_statistics_result::~ThriftHiveMetastore_get_partition_column_statistics_result() noexcept { +} + +ThriftHiveMetastore_get_partition_column_statistics_result::ThriftHiveMetastore_get_partition_column_statistics_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partition_column_statistics_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partition_column_statistics_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_column_statistics_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partition_column_statistics_presult::~ThriftHiveMetastore_get_partition_column_statistics_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partition_column_statistics_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_table_statistics_req_args::~ThriftHiveMetastore_get_table_statistics_req_args() noexcept { +} + +ThriftHiveMetastore_get_table_statistics_req_args::ThriftHiveMetastore_get_table_statistics_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_table_statistics_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_table_statistics_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_table_statistics_req_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_table_statistics_req_pargs::~ThriftHiveMetastore_get_table_statistics_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_table_statistics_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_table_statistics_req_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_table_statistics_req_result::~ThriftHiveMetastore_get_table_statistics_req_result() noexcept { +} + +ThriftHiveMetastore_get_table_statistics_req_result::ThriftHiveMetastore_get_table_statistics_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_table_statistics_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_table_statistics_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_table_statistics_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_table_statistics_req_presult::~ThriftHiveMetastore_get_table_statistics_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_table_statistics_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partitions_statistics_req_args::~ThriftHiveMetastore_get_partitions_statistics_req_args() noexcept { +} + +ThriftHiveMetastore_get_partitions_statistics_req_args::ThriftHiveMetastore_get_partitions_statistics_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partitions_statistics_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_statistics_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_statistics_req_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_statistics_req_pargs::~ThriftHiveMetastore_get_partitions_statistics_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_statistics_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_statistics_req_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_statistics_req_result::~ThriftHiveMetastore_get_partitions_statistics_req_result() noexcept { +} + +ThriftHiveMetastore_get_partitions_statistics_req_result::ThriftHiveMetastore_get_partitions_statistics_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partitions_statistics_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_statistics_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_statistics_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_statistics_req_presult::~ThriftHiveMetastore_get_partitions_statistics_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_statistics_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_aggr_stats_for_args::~ThriftHiveMetastore_get_aggr_stats_for_args() noexcept { +} + +ThriftHiveMetastore_get_aggr_stats_for_args::ThriftHiveMetastore_get_aggr_stats_for_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_aggr_stats_for_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_aggr_stats_for_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_aggr_stats_for_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_aggr_stats_for_pargs::~ThriftHiveMetastore_get_aggr_stats_for_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_aggr_stats_for_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_aggr_stats_for_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_aggr_stats_for_result::~ThriftHiveMetastore_get_aggr_stats_for_result() noexcept { +} + +ThriftHiveMetastore_get_aggr_stats_for_result::ThriftHiveMetastore_get_aggr_stats_for_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_aggr_stats_for_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_aggr_stats_for_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_aggr_stats_for_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_aggr_stats_for_presult::~ThriftHiveMetastore_get_aggr_stats_for_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_aggr_stats_for_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_set_aggr_stats_for_args::~ThriftHiveMetastore_set_aggr_stats_for_args() noexcept { +} + +ThriftHiveMetastore_set_aggr_stats_for_args::ThriftHiveMetastore_set_aggr_stats_for_args() noexcept { +} + +uint32_t ThriftHiveMetastore_set_aggr_stats_for_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_set_aggr_stats_for_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_set_aggr_stats_for_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_set_aggr_stats_for_pargs::~ThriftHiveMetastore_set_aggr_stats_for_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_set_aggr_stats_for_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_set_aggr_stats_for_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_set_aggr_stats_for_result::~ThriftHiveMetastore_set_aggr_stats_for_result() noexcept { +} + +ThriftHiveMetastore_set_aggr_stats_for_result::ThriftHiveMetastore_set_aggr_stats_for_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_set_aggr_stats_for_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_set_aggr_stats_for_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_set_aggr_stats_for_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_set_aggr_stats_for_presult::~ThriftHiveMetastore_set_aggr_stats_for_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_set_aggr_stats_for_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_delete_partition_column_statistics_args::~ThriftHiveMetastore_delete_partition_column_statistics_args() noexcept { +} + +ThriftHiveMetastore_delete_partition_column_statistics_args::ThriftHiveMetastore_delete_partition_column_statistics_args() noexcept + : db_name(), + tbl_name(), + part_name(), + col_name(), + engine() { +} + +uint32_t ThriftHiveMetastore_delete_partition_column_statistics_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->part_name); + this->__isset.part_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->col_name); + this->__isset.col_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->engine); + this->__isset.engine = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_delete_partition_column_statistics_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_delete_partition_column_statistics_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->part_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("col_name", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->col_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("engine", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->engine); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_delete_partition_column_statistics_pargs::~ThriftHiveMetastore_delete_partition_column_statistics_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_delete_partition_column_statistics_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_delete_partition_column_statistics_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->part_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("col_name", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString((*(this->col_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("engine", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString((*(this->engine))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_delete_partition_column_statistics_result::~ThriftHiveMetastore_delete_partition_column_statistics_result() noexcept { +} + +ThriftHiveMetastore_delete_partition_column_statistics_result::ThriftHiveMetastore_delete_partition_column_statistics_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_delete_partition_column_statistics_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_delete_partition_column_statistics_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_delete_partition_column_statistics_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_delete_partition_column_statistics_presult::~ThriftHiveMetastore_delete_partition_column_statistics_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_delete_partition_column_statistics_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_delete_table_column_statistics_args::~ThriftHiveMetastore_delete_table_column_statistics_args() noexcept { +} + +ThriftHiveMetastore_delete_table_column_statistics_args::ThriftHiveMetastore_delete_table_column_statistics_args() noexcept + : db_name(), + tbl_name(), + col_name(), + engine() { +} + +uint32_t ThriftHiveMetastore_delete_table_column_statistics_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->col_name); + this->__isset.col_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->engine); + this->__isset.engine = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_delete_table_column_statistics_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_delete_table_column_statistics_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("col_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->col_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("engine", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->engine); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_delete_table_column_statistics_pargs::~ThriftHiveMetastore_delete_table_column_statistics_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_delete_table_column_statistics_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_delete_table_column_statistics_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("col_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->col_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("engine", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString((*(this->engine))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_delete_table_column_statistics_result::~ThriftHiveMetastore_delete_table_column_statistics_result() noexcept { +} + +ThriftHiveMetastore_delete_table_column_statistics_result::ThriftHiveMetastore_delete_table_column_statistics_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_delete_table_column_statistics_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_delete_table_column_statistics_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_delete_table_column_statistics_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_delete_table_column_statistics_presult::~ThriftHiveMetastore_delete_table_column_statistics_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_delete_table_column_statistics_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_create_function_args::~ThriftHiveMetastore_create_function_args() noexcept { +} + +ThriftHiveMetastore_create_function_args::ThriftHiveMetastore_create_function_args() noexcept { +} + +uint32_t ThriftHiveMetastore_create_function_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->func.read(iprot); + this->__isset.func = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_function_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_function_args"); + + xfer += oprot->writeFieldBegin("func", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->func.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_function_pargs::~ThriftHiveMetastore_create_function_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_function_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_function_pargs"); + + xfer += oprot->writeFieldBegin("func", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->func)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_function_result::~ThriftHiveMetastore_create_function_result() noexcept { +} + +ThriftHiveMetastore_create_function_result::ThriftHiveMetastore_create_function_result() noexcept { +} + +uint32_t ThriftHiveMetastore_create_function_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_function_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_function_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_function_presult::~ThriftHiveMetastore_create_function_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_function_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_function_args::~ThriftHiveMetastore_drop_function_args() noexcept { +} + +ThriftHiveMetastore_drop_function_args::ThriftHiveMetastore_drop_function_args() noexcept + : dbName(), + funcName() { +} + +uint32_t ThriftHiveMetastore_drop_function_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->funcName); + this->__isset.funcName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_function_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_function_args"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("funcName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->funcName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_function_pargs::~ThriftHiveMetastore_drop_function_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_function_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_function_pargs"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->dbName))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("funcName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->funcName))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_function_result::~ThriftHiveMetastore_drop_function_result() noexcept { +} + +ThriftHiveMetastore_drop_function_result::ThriftHiveMetastore_drop_function_result() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_function_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_function_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_function_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_function_presult::~ThriftHiveMetastore_drop_function_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_function_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_alter_function_args::~ThriftHiveMetastore_alter_function_args() noexcept { +} + +ThriftHiveMetastore_alter_function_args::ThriftHiveMetastore_alter_function_args() noexcept + : dbName(), + funcName() { +} + +uint32_t ThriftHiveMetastore_alter_function_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->funcName); + this->__isset.funcName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->newFunc.read(iprot); + this->__isset.newFunc = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_function_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_function_args"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("funcName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->funcName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("newFunc", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->newFunc.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_function_pargs::~ThriftHiveMetastore_alter_function_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_function_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_function_pargs"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->dbName))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("funcName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->funcName))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("newFunc", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += (*(this->newFunc)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_function_result::~ThriftHiveMetastore_alter_function_result() noexcept { +} + +ThriftHiveMetastore_alter_function_result::ThriftHiveMetastore_alter_function_result() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_function_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_function_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_function_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_function_presult::~ThriftHiveMetastore_alter_function_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_function_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_functions_args::~ThriftHiveMetastore_get_functions_args() noexcept { +} + +ThriftHiveMetastore_get_functions_args::ThriftHiveMetastore_get_functions_args() noexcept + : dbName(), + pattern() { +} + +uint32_t ThriftHiveMetastore_get_functions_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->pattern); + this->__isset.pattern = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_functions_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_functions_args"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("pattern", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->pattern); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_functions_pargs::~ThriftHiveMetastore_get_functions_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_functions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_functions_pargs"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->dbName))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("pattern", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->pattern))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_functions_result::~ThriftHiveMetastore_get_functions_result() noexcept { +} + +ThriftHiveMetastore_get_functions_result::ThriftHiveMetastore_get_functions_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_functions_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2474; + ::apache::thrift::protocol::TType _etype2477; + xfer += iprot->readListBegin(_etype2477, _size2474); + this->success.resize(_size2474); + uint32_t _i2478; + for (_i2478 = 0; _i2478 < _size2474; ++_i2478) + { + xfer += iprot->readString(this->success[_i2478]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_functions_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_functions_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::vector ::const_iterator _iter2479; + for (_iter2479 = this->success.begin(); _iter2479 != this->success.end(); ++_iter2479) + { + xfer += oprot->writeString((*_iter2479)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_functions_presult::~ThriftHiveMetastore_get_functions_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_functions_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2480; + ::apache::thrift::protocol::TType _etype2483; + xfer += iprot->readListBegin(_etype2483, _size2480); + (*(this->success)).resize(_size2480); + uint32_t _i2484; + for (_i2484 = 0; _i2484 < _size2480; ++_i2484) + { + xfer += iprot->readString((*(this->success))[_i2484]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_function_args::~ThriftHiveMetastore_get_function_args() noexcept { +} + +ThriftHiveMetastore_get_function_args::ThriftHiveMetastore_get_function_args() noexcept + : dbName(), + funcName() { +} + +uint32_t ThriftHiveMetastore_get_function_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->funcName); + this->__isset.funcName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_function_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_function_args"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("funcName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->funcName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_function_pargs::~ThriftHiveMetastore_get_function_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_function_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_function_pargs"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->dbName))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("funcName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->funcName))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_function_result::~ThriftHiveMetastore_get_function_result() noexcept { +} + +ThriftHiveMetastore_get_function_result::ThriftHiveMetastore_get_function_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_function_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_function_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_function_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_function_presult::~ThriftHiveMetastore_get_function_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_function_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_all_functions_args::~ThriftHiveMetastore_get_all_functions_args() noexcept { +} + +ThriftHiveMetastore_get_all_functions_args::ThriftHiveMetastore_get_all_functions_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_all_functions_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_all_functions_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_functions_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_functions_pargs::~ThriftHiveMetastore_get_all_functions_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_all_functions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_functions_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_functions_result::~ThriftHiveMetastore_get_all_functions_result() noexcept { +} + +ThriftHiveMetastore_get_all_functions_result::ThriftHiveMetastore_get_all_functions_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_all_functions_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_all_functions_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_functions_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_functions_presult::~ThriftHiveMetastore_get_all_functions_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_all_functions_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_create_role_args::~ThriftHiveMetastore_create_role_args() noexcept { +} + +ThriftHiveMetastore_create_role_args::ThriftHiveMetastore_create_role_args() noexcept { +} + +uint32_t ThriftHiveMetastore_create_role_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->role.read(iprot); + this->__isset.role = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_role_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_role_args"); + + xfer += oprot->writeFieldBegin("role", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->role.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_role_pargs::~ThriftHiveMetastore_create_role_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_role_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_role_pargs"); + + xfer += oprot->writeFieldBegin("role", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->role)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_role_result::~ThriftHiveMetastore_create_role_result() noexcept { +} + +ThriftHiveMetastore_create_role_result::ThriftHiveMetastore_create_role_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_create_role_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_role_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_role_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_role_presult::~ThriftHiveMetastore_create_role_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_role_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_role_args::~ThriftHiveMetastore_drop_role_args() noexcept { +} + +ThriftHiveMetastore_drop_role_args::ThriftHiveMetastore_drop_role_args() noexcept + : role_name() { +} + +uint32_t ThriftHiveMetastore_drop_role_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->role_name); + this->__isset.role_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_role_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_role_args"); + + xfer += oprot->writeFieldBegin("role_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->role_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_role_pargs::~ThriftHiveMetastore_drop_role_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_role_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_role_pargs"); + + xfer += oprot->writeFieldBegin("role_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->role_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_role_result::~ThriftHiveMetastore_drop_role_result() noexcept { +} + +ThriftHiveMetastore_drop_role_result::ThriftHiveMetastore_drop_role_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_drop_role_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_role_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_role_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_role_presult::~ThriftHiveMetastore_drop_role_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_role_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_role_names_args::~ThriftHiveMetastore_get_role_names_args() noexcept { +} + +ThriftHiveMetastore_get_role_names_args::ThriftHiveMetastore_get_role_names_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_role_names_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_role_names_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_role_names_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_role_names_pargs::~ThriftHiveMetastore_get_role_names_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_role_names_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_role_names_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_role_names_result::~ThriftHiveMetastore_get_role_names_result() noexcept { +} + +ThriftHiveMetastore_get_role_names_result::ThriftHiveMetastore_get_role_names_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_role_names_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2485; + ::apache::thrift::protocol::TType _etype2488; + xfer += iprot->readListBegin(_etype2488, _size2485); + this->success.resize(_size2485); + uint32_t _i2489; + for (_i2489 = 0; _i2489 < _size2485; ++_i2489) + { + xfer += iprot->readString(this->success[_i2489]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_role_names_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_role_names_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::vector ::const_iterator _iter2490; + for (_iter2490 = this->success.begin(); _iter2490 != this->success.end(); ++_iter2490) + { + xfer += oprot->writeString((*_iter2490)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_role_names_presult::~ThriftHiveMetastore_get_role_names_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_role_names_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2491; + ::apache::thrift::protocol::TType _etype2494; + xfer += iprot->readListBegin(_etype2494, _size2491); + (*(this->success)).resize(_size2491); + uint32_t _i2495; + for (_i2495 = 0; _i2495 < _size2491; ++_i2495) + { + xfer += iprot->readString((*(this->success))[_i2495]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_grant_role_args::~ThriftHiveMetastore_grant_role_args() noexcept { +} + +ThriftHiveMetastore_grant_role_args::ThriftHiveMetastore_grant_role_args() noexcept + : role_name(), + principal_name(), + principal_type(static_cast(0)), + grantor(), + grantorType(static_cast(0)), + grant_option(0) { +} + +uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->role_name); + this->__isset.role_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->principal_name); + this->__isset.principal_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast2496; + xfer += iprot->readI32(ecast2496); + this->principal_type = static_cast(ecast2496); + this->__isset.principal_type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->grantor); + this->__isset.grantor = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast2497; + xfer += iprot->readI32(ecast2497); + this->grantorType = static_cast(ecast2497); + this->__isset.grantorType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->grant_option); + this->__isset.grant_option = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_grant_role_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_role_args"); + + xfer += oprot->writeFieldBegin("role_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->role_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principal_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->principal_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32(static_cast(this->principal_type)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("grantor", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->grantor); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("grantorType", ::apache::thrift::protocol::T_I32, 5); + xfer += oprot->writeI32(static_cast(this->grantorType)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("grant_option", ::apache::thrift::protocol::T_BOOL, 6); + xfer += oprot->writeBool(this->grant_option); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_grant_role_pargs::~ThriftHiveMetastore_grant_role_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_grant_role_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_role_pargs"); + + xfer += oprot->writeFieldBegin("role_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->role_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principal_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->principal_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32(static_cast((*(this->principal_type)))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("grantor", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString((*(this->grantor))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("grantorType", ::apache::thrift::protocol::T_I32, 5); + xfer += oprot->writeI32(static_cast((*(this->grantorType)))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("grant_option", ::apache::thrift::protocol::T_BOOL, 6); + xfer += oprot->writeBool((*(this->grant_option))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_grant_role_result::~ThriftHiveMetastore_grant_role_result() noexcept { +} + +ThriftHiveMetastore_grant_role_result::ThriftHiveMetastore_grant_role_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_grant_role_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_grant_role_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_role_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_grant_role_presult::~ThriftHiveMetastore_grant_role_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_grant_role_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_revoke_role_args::~ThriftHiveMetastore_revoke_role_args() noexcept { +} + +ThriftHiveMetastore_revoke_role_args::ThriftHiveMetastore_revoke_role_args() noexcept + : role_name(), + principal_name(), + principal_type(static_cast(0)) { +} + +uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->role_name); + this->__isset.role_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->principal_name); + this->__isset.principal_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast2498; + xfer += iprot->readI32(ecast2498); + this->principal_type = static_cast(ecast2498); + this->__isset.principal_type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_revoke_role_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_revoke_role_args"); + + xfer += oprot->writeFieldBegin("role_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->role_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principal_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->principal_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32(static_cast(this->principal_type)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_revoke_role_pargs::~ThriftHiveMetastore_revoke_role_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_revoke_role_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_revoke_role_pargs"); + + xfer += oprot->writeFieldBegin("role_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->role_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principal_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->principal_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32(static_cast((*(this->principal_type)))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_revoke_role_result::~ThriftHiveMetastore_revoke_role_result() noexcept { +} + +ThriftHiveMetastore_revoke_role_result::ThriftHiveMetastore_revoke_role_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_revoke_role_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_revoke_role_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_revoke_role_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_revoke_role_presult::~ThriftHiveMetastore_revoke_role_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_revoke_role_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_list_roles_args::~ThriftHiveMetastore_list_roles_args() noexcept { +} + +ThriftHiveMetastore_list_roles_args::ThriftHiveMetastore_list_roles_args() noexcept + : principal_name(), + principal_type(static_cast(0)) { +} + +uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->principal_name); + this->__isset.principal_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast2499; + xfer += iprot->readI32(ecast2499); + this->principal_type = static_cast(ecast2499); + this->__isset.principal_type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_list_roles_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_roles_args"); + + xfer += oprot->writeFieldBegin("principal_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->principal_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(static_cast(this->principal_type)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_list_roles_pargs::~ThriftHiveMetastore_list_roles_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_list_roles_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_roles_pargs"); + + xfer += oprot->writeFieldBegin("principal_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->principal_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(static_cast((*(this->principal_type)))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_list_roles_result::~ThriftHiveMetastore_list_roles_result() noexcept { +} + +ThriftHiveMetastore_list_roles_result::ThriftHiveMetastore_list_roles_result() noexcept { +} + +uint32_t ThriftHiveMetastore_list_roles_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2500; + ::apache::thrift::protocol::TType _etype2503; + xfer += iprot->readListBegin(_etype2503, _size2500); + this->success.resize(_size2500); + uint32_t _i2504; + for (_i2504 = 0; _i2504 < _size2500; ++_i2504) + { + xfer += this->success[_i2504].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_list_roles_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_roles_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter2505; + for (_iter2505 = this->success.begin(); _iter2505 != this->success.end(); ++_iter2505) + { + xfer += (*_iter2505).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_list_roles_presult::~ThriftHiveMetastore_list_roles_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2506; + ::apache::thrift::protocol::TType _etype2509; + xfer += iprot->readListBegin(_etype2509, _size2506); + (*(this->success)).resize(_size2506); + uint32_t _i2510; + for (_i2510 = 0; _i2510 < _size2506; ++_i2510) + { + xfer += (*(this->success))[_i2510].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_grant_revoke_role_args::~ThriftHiveMetastore_grant_revoke_role_args() noexcept { +} + +ThriftHiveMetastore_grant_revoke_role_args::ThriftHiveMetastore_grant_revoke_role_args() noexcept { +} + +uint32_t ThriftHiveMetastore_grant_revoke_role_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_grant_revoke_role_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_revoke_role_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_grant_revoke_role_pargs::~ThriftHiveMetastore_grant_revoke_role_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_grant_revoke_role_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_revoke_role_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_grant_revoke_role_result::~ThriftHiveMetastore_grant_revoke_role_result() noexcept { +} + +ThriftHiveMetastore_grant_revoke_role_result::ThriftHiveMetastore_grant_revoke_role_result() noexcept { +} + +uint32_t ThriftHiveMetastore_grant_revoke_role_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_grant_revoke_role_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_revoke_role_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_grant_revoke_role_presult::~ThriftHiveMetastore_grant_revoke_role_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_grant_revoke_role_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_principals_in_role_args::~ThriftHiveMetastore_get_principals_in_role_args() noexcept { +} + +ThriftHiveMetastore_get_principals_in_role_args::ThriftHiveMetastore_get_principals_in_role_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_principals_in_role_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_principals_in_role_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_principals_in_role_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_principals_in_role_pargs::~ThriftHiveMetastore_get_principals_in_role_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_principals_in_role_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_principals_in_role_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_principals_in_role_result::~ThriftHiveMetastore_get_principals_in_role_result() noexcept { +} + +ThriftHiveMetastore_get_principals_in_role_result::ThriftHiveMetastore_get_principals_in_role_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_principals_in_role_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_principals_in_role_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_principals_in_role_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_principals_in_role_presult::~ThriftHiveMetastore_get_principals_in_role_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_principals_in_role_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_role_grants_for_principal_args::~ThriftHiveMetastore_get_role_grants_for_principal_args() noexcept { +} + +ThriftHiveMetastore_get_role_grants_for_principal_args::ThriftHiveMetastore_get_role_grants_for_principal_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_role_grants_for_principal_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_role_grants_for_principal_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_role_grants_for_principal_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_role_grants_for_principal_pargs::~ThriftHiveMetastore_get_role_grants_for_principal_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_role_grants_for_principal_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_role_grants_for_principal_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_role_grants_for_principal_result::~ThriftHiveMetastore_get_role_grants_for_principal_result() noexcept { +} + +ThriftHiveMetastore_get_role_grants_for_principal_result::ThriftHiveMetastore_get_role_grants_for_principal_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_role_grants_for_principal_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_role_grants_for_principal_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_role_grants_for_principal_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_role_grants_for_principal_presult::~ThriftHiveMetastore_get_role_grants_for_principal_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_role_grants_for_principal_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_privilege_set_args::~ThriftHiveMetastore_get_privilege_set_args() noexcept { +} + +ThriftHiveMetastore_get_privilege_set_args::ThriftHiveMetastore_get_privilege_set_args() noexcept + : user_name() { +} + +uint32_t ThriftHiveMetastore_get_privilege_set_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->hiveObject.read(iprot); + this->__isset.hiveObject = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->user_name); + this->__isset.user_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->group_names.clear(); + uint32_t _size2511; + ::apache::thrift::protocol::TType _etype2514; + xfer += iprot->readListBegin(_etype2514, _size2511); + this->group_names.resize(_size2511); + uint32_t _i2515; + for (_i2515 = 0; _i2515 < _size2511; ++_i2515) + { + xfer += iprot->readString(this->group_names[_i2515]); + } + xfer += iprot->readListEnd(); + } + this->__isset.group_names = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_privilege_set_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_privilege_set_args"); + + xfer += oprot->writeFieldBegin("hiveObject", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->hiveObject.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->user_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); + std::vector ::const_iterator _iter2516; + for (_iter2516 = this->group_names.begin(); _iter2516 != this->group_names.end(); ++_iter2516) + { + xfer += oprot->writeString((*_iter2516)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_privilege_set_pargs::~ThriftHiveMetastore_get_privilege_set_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_privilege_set_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_privilege_set_pargs"); + + xfer += oprot->writeFieldBegin("hiveObject", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->hiveObject)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->user_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); + std::vector ::const_iterator _iter2517; + for (_iter2517 = (*(this->group_names)).begin(); _iter2517 != (*(this->group_names)).end(); ++_iter2517) + { + xfer += oprot->writeString((*_iter2517)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_privilege_set_result::~ThriftHiveMetastore_get_privilege_set_result() noexcept { +} + +ThriftHiveMetastore_get_privilege_set_result::ThriftHiveMetastore_get_privilege_set_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_privilege_set_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_privilege_set_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_privilege_set_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_privilege_set_presult::~ThriftHiveMetastore_get_privilege_set_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_privilege_set_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_list_privileges_args::~ThriftHiveMetastore_list_privileges_args() noexcept { +} + +ThriftHiveMetastore_list_privileges_args::ThriftHiveMetastore_list_privileges_args() noexcept + : principal_name(), + principal_type(static_cast(0)) { +} + +uint32_t ThriftHiveMetastore_list_privileges_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->principal_name); + this->__isset.principal_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast2518; + xfer += iprot->readI32(ecast2518); + this->principal_type = static_cast(ecast2518); + this->__isset.principal_type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->hiveObject.read(iprot); + this->__isset.hiveObject = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_list_privileges_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_privileges_args"); + + xfer += oprot->writeFieldBegin("principal_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->principal_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(static_cast(this->principal_type)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("hiveObject", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->hiveObject.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_list_privileges_pargs::~ThriftHiveMetastore_list_privileges_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_list_privileges_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_privileges_pargs"); + + xfer += oprot->writeFieldBegin("principal_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->principal_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(static_cast((*(this->principal_type)))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("hiveObject", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += (*(this->hiveObject)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_list_privileges_result::~ThriftHiveMetastore_list_privileges_result() noexcept { +} + +ThriftHiveMetastore_list_privileges_result::ThriftHiveMetastore_list_privileges_result() noexcept { +} + +uint32_t ThriftHiveMetastore_list_privileges_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2519; + ::apache::thrift::protocol::TType _etype2522; + xfer += iprot->readListBegin(_etype2522, _size2519); + this->success.resize(_size2519); + uint32_t _i2523; + for (_i2523 = 0; _i2523 < _size2519; ++_i2523) + { + xfer += this->success[_i2523].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_list_privileges_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_privileges_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter2524; + for (_iter2524 = this->success.begin(); _iter2524 != this->success.end(); ++_iter2524) + { + xfer += (*_iter2524).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_list_privileges_presult::~ThriftHiveMetastore_list_privileges_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_list_privileges_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2525; + ::apache::thrift::protocol::TType _etype2528; + xfer += iprot->readListBegin(_etype2528, _size2525); + (*(this->success)).resize(_size2525); + uint32_t _i2529; + for (_i2529 = 0; _i2529 < _size2525; ++_i2529) + { + xfer += (*(this->success))[_i2529].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_grant_privileges_args::~ThriftHiveMetastore_grant_privileges_args() noexcept { +} + +ThriftHiveMetastore_grant_privileges_args::ThriftHiveMetastore_grant_privileges_args() noexcept { +} + +uint32_t ThriftHiveMetastore_grant_privileges_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->privileges.read(iprot); + this->__isset.privileges = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_grant_privileges_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_privileges_args"); + + xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->privileges.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_grant_privileges_pargs::~ThriftHiveMetastore_grant_privileges_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_grant_privileges_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_privileges_pargs"); + + xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->privileges)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_grant_privileges_result::~ThriftHiveMetastore_grant_privileges_result() noexcept { +} + +ThriftHiveMetastore_grant_privileges_result::ThriftHiveMetastore_grant_privileges_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_grant_privileges_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_grant_privileges_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_privileges_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_grant_privileges_presult::~ThriftHiveMetastore_grant_privileges_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_grant_privileges_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_revoke_privileges_args::~ThriftHiveMetastore_revoke_privileges_args() noexcept { +} + +ThriftHiveMetastore_revoke_privileges_args::ThriftHiveMetastore_revoke_privileges_args() noexcept { +} + +uint32_t ThriftHiveMetastore_revoke_privileges_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->privileges.read(iprot); + this->__isset.privileges = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_revoke_privileges_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_revoke_privileges_args"); + + xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->privileges.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_revoke_privileges_pargs::~ThriftHiveMetastore_revoke_privileges_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_revoke_privileges_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_revoke_privileges_pargs"); + + xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->privileges)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_revoke_privileges_result::~ThriftHiveMetastore_revoke_privileges_result() noexcept { +} + +ThriftHiveMetastore_revoke_privileges_result::ThriftHiveMetastore_revoke_privileges_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_revoke_privileges_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_revoke_privileges_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_revoke_privileges_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_revoke_privileges_presult::~ThriftHiveMetastore_revoke_privileges_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_revoke_privileges_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_grant_revoke_privileges_args::~ThriftHiveMetastore_grant_revoke_privileges_args() noexcept { +} + +ThriftHiveMetastore_grant_revoke_privileges_args::ThriftHiveMetastore_grant_revoke_privileges_args() noexcept { +} + +uint32_t ThriftHiveMetastore_grant_revoke_privileges_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_grant_revoke_privileges_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_revoke_privileges_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_grant_revoke_privileges_pargs::~ThriftHiveMetastore_grant_revoke_privileges_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_grant_revoke_privileges_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_revoke_privileges_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_grant_revoke_privileges_result::~ThriftHiveMetastore_grant_revoke_privileges_result() noexcept { +} + +ThriftHiveMetastore_grant_revoke_privileges_result::ThriftHiveMetastore_grant_revoke_privileges_result() noexcept { +} + +uint32_t ThriftHiveMetastore_grant_revoke_privileges_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_grant_revoke_privileges_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_revoke_privileges_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_grant_revoke_privileges_presult::~ThriftHiveMetastore_grant_revoke_privileges_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_grant_revoke_privileges_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_refresh_privileges_args::~ThriftHiveMetastore_refresh_privileges_args() noexcept { +} + +ThriftHiveMetastore_refresh_privileges_args::ThriftHiveMetastore_refresh_privileges_args() noexcept + : authorizer() { +} + +uint32_t ThriftHiveMetastore_refresh_privileges_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->objToRefresh.read(iprot); + this->__isset.objToRefresh = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->authorizer); + this->__isset.authorizer = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->grantRequest.read(iprot); + this->__isset.grantRequest = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_refresh_privileges_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_refresh_privileges_args"); + + xfer += oprot->writeFieldBegin("objToRefresh", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->objToRefresh.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("authorizer", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->authorizer); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("grantRequest", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->grantRequest.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_refresh_privileges_pargs::~ThriftHiveMetastore_refresh_privileges_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_refresh_privileges_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_refresh_privileges_pargs"); + + xfer += oprot->writeFieldBegin("objToRefresh", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->objToRefresh)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("authorizer", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->authorizer))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("grantRequest", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += (*(this->grantRequest)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_refresh_privileges_result::~ThriftHiveMetastore_refresh_privileges_result() noexcept { +} + +ThriftHiveMetastore_refresh_privileges_result::ThriftHiveMetastore_refresh_privileges_result() noexcept { +} + +uint32_t ThriftHiveMetastore_refresh_privileges_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_refresh_privileges_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_refresh_privileges_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_refresh_privileges_presult::~ThriftHiveMetastore_refresh_privileges_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_refresh_privileges_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_set_ugi_args::~ThriftHiveMetastore_set_ugi_args() noexcept { +} + +ThriftHiveMetastore_set_ugi_args::ThriftHiveMetastore_set_ugi_args() noexcept + : user_name() { +} + +uint32_t ThriftHiveMetastore_set_ugi_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->user_name); + this->__isset.user_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->group_names.clear(); + uint32_t _size2530; + ::apache::thrift::protocol::TType _etype2533; + xfer += iprot->readListBegin(_etype2533, _size2530); + this->group_names.resize(_size2530); + uint32_t _i2534; + for (_i2534 = 0; _i2534 < _size2530; ++_i2534) + { + xfer += iprot->readString(this->group_names[_i2534]); + } + xfer += iprot->readListEnd(); + } + this->__isset.group_names = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_set_ugi_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_set_ugi_args"); + + xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->user_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); + std::vector ::const_iterator _iter2535; + for (_iter2535 = this->group_names.begin(); _iter2535 != this->group_names.end(); ++_iter2535) + { + xfer += oprot->writeString((*_iter2535)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_set_ugi_pargs::~ThriftHiveMetastore_set_ugi_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_set_ugi_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_set_ugi_pargs"); + + xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->user_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); + std::vector ::const_iterator _iter2536; + for (_iter2536 = (*(this->group_names)).begin(); _iter2536 != (*(this->group_names)).end(); ++_iter2536) + { + xfer += oprot->writeString((*_iter2536)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_set_ugi_result::~ThriftHiveMetastore_set_ugi_result() noexcept { +} + +ThriftHiveMetastore_set_ugi_result::ThriftHiveMetastore_set_ugi_result() noexcept { +} + +uint32_t ThriftHiveMetastore_set_ugi_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2537; + ::apache::thrift::protocol::TType _etype2540; + xfer += iprot->readListBegin(_etype2540, _size2537); + this->success.resize(_size2537); + uint32_t _i2541; + for (_i2541 = 0; _i2541 < _size2537; ++_i2541) + { + xfer += iprot->readString(this->success[_i2541]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_set_ugi_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_set_ugi_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::vector ::const_iterator _iter2542; + for (_iter2542 = this->success.begin(); _iter2542 != this->success.end(); ++_iter2542) + { + xfer += oprot->writeString((*_iter2542)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_set_ugi_presult::~ThriftHiveMetastore_set_ugi_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_set_ugi_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2543; + ::apache::thrift::protocol::TType _etype2546; + xfer += iprot->readListBegin(_etype2546, _size2543); + (*(this->success)).resize(_size2543); + uint32_t _i2547; + for (_i2547 = 0; _i2547 < _size2543; ++_i2547) + { + xfer += iprot->readString((*(this->success))[_i2547]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_delegation_token_args::~ThriftHiveMetastore_get_delegation_token_args() noexcept { +} + +ThriftHiveMetastore_get_delegation_token_args::ThriftHiveMetastore_get_delegation_token_args() noexcept + : token_owner(), + renewer_kerberos_principal_name() { +} + +uint32_t ThriftHiveMetastore_get_delegation_token_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->token_owner); + this->__isset.token_owner = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->renewer_kerberos_principal_name); + this->__isset.renewer_kerberos_principal_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_delegation_token_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_delegation_token_args"); + + xfer += oprot->writeFieldBegin("token_owner", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->token_owner); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("renewer_kerberos_principal_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->renewer_kerberos_principal_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_delegation_token_pargs::~ThriftHiveMetastore_get_delegation_token_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_delegation_token_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_delegation_token_pargs"); + + xfer += oprot->writeFieldBegin("token_owner", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->token_owner))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("renewer_kerberos_principal_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->renewer_kerberos_principal_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_delegation_token_result::~ThriftHiveMetastore_get_delegation_token_result() noexcept { +} + +ThriftHiveMetastore_get_delegation_token_result::ThriftHiveMetastore_get_delegation_token_result() noexcept + : success() { +} + +uint32_t ThriftHiveMetastore_get_delegation_token_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_delegation_token_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_delegation_token_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0); + xfer += oprot->writeString(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_delegation_token_presult::~ThriftHiveMetastore_get_delegation_token_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_delegation_token_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_renew_delegation_token_args::~ThriftHiveMetastore_renew_delegation_token_args() noexcept { +} + +ThriftHiveMetastore_renew_delegation_token_args::ThriftHiveMetastore_renew_delegation_token_args() noexcept + : token_str_form() { +} + +uint32_t ThriftHiveMetastore_renew_delegation_token_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->token_str_form); + this->__isset.token_str_form = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_renew_delegation_token_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_renew_delegation_token_args"); + + xfer += oprot->writeFieldBegin("token_str_form", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->token_str_form); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_renew_delegation_token_pargs::~ThriftHiveMetastore_renew_delegation_token_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_renew_delegation_token_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_renew_delegation_token_pargs"); + + xfer += oprot->writeFieldBegin("token_str_form", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->token_str_form))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_renew_delegation_token_result::~ThriftHiveMetastore_renew_delegation_token_result() noexcept { +} + +ThriftHiveMetastore_renew_delegation_token_result::ThriftHiveMetastore_renew_delegation_token_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_renew_delegation_token_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_renew_delegation_token_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_renew_delegation_token_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I64, 0); + xfer += oprot->writeI64(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_renew_delegation_token_presult::~ThriftHiveMetastore_renew_delegation_token_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_renew_delegation_token_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_cancel_delegation_token_args::~ThriftHiveMetastore_cancel_delegation_token_args() noexcept { +} + +ThriftHiveMetastore_cancel_delegation_token_args::ThriftHiveMetastore_cancel_delegation_token_args() noexcept + : token_str_form() { +} + +uint32_t ThriftHiveMetastore_cancel_delegation_token_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->token_str_form); + this->__isset.token_str_form = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_cancel_delegation_token_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cancel_delegation_token_args"); + + xfer += oprot->writeFieldBegin("token_str_form", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->token_str_form); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_cancel_delegation_token_pargs::~ThriftHiveMetastore_cancel_delegation_token_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_cancel_delegation_token_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cancel_delegation_token_pargs"); + + xfer += oprot->writeFieldBegin("token_str_form", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->token_str_form))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_cancel_delegation_token_result::~ThriftHiveMetastore_cancel_delegation_token_result() noexcept { +} + +ThriftHiveMetastore_cancel_delegation_token_result::ThriftHiveMetastore_cancel_delegation_token_result() noexcept { +} + +uint32_t ThriftHiveMetastore_cancel_delegation_token_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_cancel_delegation_token_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cancel_delegation_token_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_cancel_delegation_token_presult::~ThriftHiveMetastore_cancel_delegation_token_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_cancel_delegation_token_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_token_args::~ThriftHiveMetastore_add_token_args() noexcept { +} + +ThriftHiveMetastore_add_token_args::ThriftHiveMetastore_add_token_args() noexcept + : token_identifier(), + delegation_token() { +} + +uint32_t ThriftHiveMetastore_add_token_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->token_identifier); + this->__isset.token_identifier = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->delegation_token); + this->__isset.delegation_token = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_token_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_token_args"); + + xfer += oprot->writeFieldBegin("token_identifier", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->token_identifier); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("delegation_token", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->delegation_token); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_token_pargs::~ThriftHiveMetastore_add_token_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_token_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_token_pargs"); + + xfer += oprot->writeFieldBegin("token_identifier", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->token_identifier))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("delegation_token", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->delegation_token))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_token_result::~ThriftHiveMetastore_add_token_result() noexcept { +} + +ThriftHiveMetastore_add_token_result::ThriftHiveMetastore_add_token_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_add_token_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_token_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_token_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_token_presult::~ThriftHiveMetastore_add_token_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_token_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_remove_token_args::~ThriftHiveMetastore_remove_token_args() noexcept { +} + +ThriftHiveMetastore_remove_token_args::ThriftHiveMetastore_remove_token_args() noexcept + : token_identifier() { +} + +uint32_t ThriftHiveMetastore_remove_token_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->token_identifier); + this->__isset.token_identifier = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_remove_token_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_remove_token_args"); + + xfer += oprot->writeFieldBegin("token_identifier", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->token_identifier); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_remove_token_pargs::~ThriftHiveMetastore_remove_token_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_remove_token_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_remove_token_pargs"); + + xfer += oprot->writeFieldBegin("token_identifier", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->token_identifier))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_remove_token_result::~ThriftHiveMetastore_remove_token_result() noexcept { +} + +ThriftHiveMetastore_remove_token_result::ThriftHiveMetastore_remove_token_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_remove_token_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_remove_token_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_remove_token_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_remove_token_presult::~ThriftHiveMetastore_remove_token_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_remove_token_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_token_args::~ThriftHiveMetastore_get_token_args() noexcept { +} + +ThriftHiveMetastore_get_token_args::ThriftHiveMetastore_get_token_args() noexcept + : token_identifier() { +} + +uint32_t ThriftHiveMetastore_get_token_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->token_identifier); + this->__isset.token_identifier = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_token_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_token_args"); + + xfer += oprot->writeFieldBegin("token_identifier", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->token_identifier); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_token_pargs::~ThriftHiveMetastore_get_token_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_token_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_token_pargs"); + + xfer += oprot->writeFieldBegin("token_identifier", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->token_identifier))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_token_result::~ThriftHiveMetastore_get_token_result() noexcept { +} + +ThriftHiveMetastore_get_token_result::ThriftHiveMetastore_get_token_result() noexcept + : success() { +} + +uint32_t ThriftHiveMetastore_get_token_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_token_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_token_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0); + xfer += oprot->writeString(this->success); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_token_presult::~ThriftHiveMetastore_get_token_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_token_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_all_token_identifiers_args::~ThriftHiveMetastore_get_all_token_identifiers_args() noexcept { +} + +ThriftHiveMetastore_get_all_token_identifiers_args::ThriftHiveMetastore_get_all_token_identifiers_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_all_token_identifiers_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_all_token_identifiers_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_token_identifiers_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_token_identifiers_pargs::~ThriftHiveMetastore_get_all_token_identifiers_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_all_token_identifiers_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_token_identifiers_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_token_identifiers_result::~ThriftHiveMetastore_get_all_token_identifiers_result() noexcept { +} + +ThriftHiveMetastore_get_all_token_identifiers_result::ThriftHiveMetastore_get_all_token_identifiers_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2548; + ::apache::thrift::protocol::TType _etype2551; + xfer += iprot->readListBegin(_etype2551, _size2548); + this->success.resize(_size2548); + uint32_t _i2552; + for (_i2552 = 0; _i2552 < _size2548; ++_i2552) + { + xfer += iprot->readString(this->success[_i2552]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_token_identifiers_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::vector ::const_iterator _iter2553; + for (_iter2553 = this->success.begin(); _iter2553 != this->success.end(); ++_iter2553) + { + xfer += oprot->writeString((*_iter2553)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_token_identifiers_presult::~ThriftHiveMetastore_get_all_token_identifiers_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_all_token_identifiers_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2554; + ::apache::thrift::protocol::TType _etype2557; + xfer += iprot->readListBegin(_etype2557, _size2554); + (*(this->success)).resize(_size2554); + uint32_t _i2558; + for (_i2558 = 0; _i2558 < _size2554; ++_i2558) + { + xfer += iprot->readString((*(this->success))[_i2558]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_master_key_args::~ThriftHiveMetastore_add_master_key_args() noexcept { +} + +ThriftHiveMetastore_add_master_key_args::ThriftHiveMetastore_add_master_key_args() noexcept + : key() { +} + +uint32_t ThriftHiveMetastore_add_master_key_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->key); + this->__isset.key = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_master_key_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_master_key_args"); + + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->key); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_master_key_pargs::~ThriftHiveMetastore_add_master_key_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_master_key_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_master_key_pargs"); + + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->key))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_master_key_result::~ThriftHiveMetastore_add_master_key_result() noexcept { +} + +ThriftHiveMetastore_add_master_key_result::ThriftHiveMetastore_add_master_key_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_add_master_key_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_master_key_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_master_key_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0); + xfer += oprot->writeI32(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_master_key_presult::~ThriftHiveMetastore_add_master_key_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_master_key_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_update_master_key_args::~ThriftHiveMetastore_update_master_key_args() noexcept { +} + +ThriftHiveMetastore_update_master_key_args::ThriftHiveMetastore_update_master_key_args() noexcept + : seq_number(0), + key() { +} + +uint32_t ThriftHiveMetastore_update_master_key_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->seq_number); + this->__isset.seq_number = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->key); + this->__isset.key = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_update_master_key_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_master_key_args"); + + xfer += oprot->writeFieldBegin("seq_number", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32(this->seq_number); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->key); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_master_key_pargs::~ThriftHiveMetastore_update_master_key_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_update_master_key_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_master_key_pargs"); + + xfer += oprot->writeFieldBegin("seq_number", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32((*(this->seq_number))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->key))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_master_key_result::~ThriftHiveMetastore_update_master_key_result() noexcept { +} + +ThriftHiveMetastore_update_master_key_result::ThriftHiveMetastore_update_master_key_result() noexcept { +} + +uint32_t ThriftHiveMetastore_update_master_key_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_update_master_key_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_master_key_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_master_key_presult::~ThriftHiveMetastore_update_master_key_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_update_master_key_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_remove_master_key_args::~ThriftHiveMetastore_remove_master_key_args() noexcept { +} + +ThriftHiveMetastore_remove_master_key_args::ThriftHiveMetastore_remove_master_key_args() noexcept + : key_seq(0) { +} + +uint32_t ThriftHiveMetastore_remove_master_key_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->key_seq); + this->__isset.key_seq = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_remove_master_key_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_remove_master_key_args"); + + xfer += oprot->writeFieldBegin("key_seq", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32(this->key_seq); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_remove_master_key_pargs::~ThriftHiveMetastore_remove_master_key_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_remove_master_key_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_remove_master_key_pargs"); + + xfer += oprot->writeFieldBegin("key_seq", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32((*(this->key_seq))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_remove_master_key_result::~ThriftHiveMetastore_remove_master_key_result() noexcept { +} + +ThriftHiveMetastore_remove_master_key_result::ThriftHiveMetastore_remove_master_key_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_remove_master_key_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_remove_master_key_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_remove_master_key_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_remove_master_key_presult::~ThriftHiveMetastore_remove_master_key_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_remove_master_key_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_master_keys_args::~ThriftHiveMetastore_get_master_keys_args() noexcept { +} + +ThriftHiveMetastore_get_master_keys_args::ThriftHiveMetastore_get_master_keys_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_master_keys_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_master_keys_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_master_keys_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_master_keys_pargs::~ThriftHiveMetastore_get_master_keys_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_master_keys_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_master_keys_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_master_keys_result::~ThriftHiveMetastore_get_master_keys_result() noexcept { +} + +ThriftHiveMetastore_get_master_keys_result::ThriftHiveMetastore_get_master_keys_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_master_keys_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2559; + ::apache::thrift::protocol::TType _etype2562; + xfer += iprot->readListBegin(_etype2562, _size2559); + this->success.resize(_size2559); + uint32_t _i2563; + for (_i2563 = 0; _i2563 < _size2559; ++_i2563) + { + xfer += iprot->readString(this->success[_i2563]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_master_keys_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_master_keys_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::vector ::const_iterator _iter2564; + for (_iter2564 = this->success.begin(); _iter2564 != this->success.end(); ++_iter2564) + { + xfer += oprot->writeString((*_iter2564)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_master_keys_presult::~ThriftHiveMetastore_get_master_keys_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_master_keys_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2565; + ::apache::thrift::protocol::TType _etype2568; + xfer += iprot->readListBegin(_etype2568, _size2565); + (*(this->success)).resize(_size2565); + uint32_t _i2569; + for (_i2569 = 0; _i2569 < _size2565; ++_i2569) + { + xfer += iprot->readString((*(this->success))[_i2569]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_open_txns_args::~ThriftHiveMetastore_get_open_txns_args() noexcept { +} + +ThriftHiveMetastore_get_open_txns_args::ThriftHiveMetastore_get_open_txns_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_open_txns_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_open_txns_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_open_txns_pargs::~ThriftHiveMetastore_get_open_txns_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_open_txns_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_open_txns_result::~ThriftHiveMetastore_get_open_txns_result() noexcept { +} + +ThriftHiveMetastore_get_open_txns_result::ThriftHiveMetastore_get_open_txns_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_open_txns_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_open_txns_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_open_txns_presult::~ThriftHiveMetastore_get_open_txns_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_open_txns_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_open_txns_info_args::~ThriftHiveMetastore_get_open_txns_info_args() noexcept { +} + +ThriftHiveMetastore_get_open_txns_info_args::ThriftHiveMetastore_get_open_txns_info_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_open_txns_info_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_open_txns_info_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_info_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_open_txns_info_pargs::~ThriftHiveMetastore_get_open_txns_info_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_open_txns_info_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_info_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_open_txns_info_result::~ThriftHiveMetastore_get_open_txns_info_result() noexcept { +} + +ThriftHiveMetastore_get_open_txns_info_result::ThriftHiveMetastore_get_open_txns_info_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_open_txns_info_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_open_txns_info_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_info_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_open_txns_info_presult::~ThriftHiveMetastore_get_open_txns_info_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_open_txns_info_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_open_txns_args::~ThriftHiveMetastore_open_txns_args() noexcept { +} + +ThriftHiveMetastore_open_txns_args::ThriftHiveMetastore_open_txns_args() noexcept { +} + +uint32_t ThriftHiveMetastore_open_txns_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_open_txns_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_open_txns_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_open_txns_pargs::~ThriftHiveMetastore_open_txns_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_open_txns_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_open_txns_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_open_txns_result::~ThriftHiveMetastore_open_txns_result() noexcept { +} + +ThriftHiveMetastore_open_txns_result::ThriftHiveMetastore_open_txns_result() noexcept { +} + +uint32_t ThriftHiveMetastore_open_txns_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_open_txns_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_open_txns_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_open_txns_presult::~ThriftHiveMetastore_open_txns_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_open_txns_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_abort_txn_args::~ThriftHiveMetastore_abort_txn_args() noexcept { +} + +ThriftHiveMetastore_abort_txn_args::ThriftHiveMetastore_abort_txn_args() noexcept { +} + +uint32_t ThriftHiveMetastore_abort_txn_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_abort_txn_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_txn_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_abort_txn_pargs::~ThriftHiveMetastore_abort_txn_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_abort_txn_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_txn_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_abort_txn_result::~ThriftHiveMetastore_abort_txn_result() noexcept { +} + +ThriftHiveMetastore_abort_txn_result::ThriftHiveMetastore_abort_txn_result() noexcept { +} + +uint32_t ThriftHiveMetastore_abort_txn_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_abort_txn_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_txn_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_abort_txn_presult::~ThriftHiveMetastore_abort_txn_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_abort_txn_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_abort_txns_args::~ThriftHiveMetastore_abort_txns_args() noexcept { +} + +ThriftHiveMetastore_abort_txns_args::ThriftHiveMetastore_abort_txns_args() noexcept { +} + +uint32_t ThriftHiveMetastore_abort_txns_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_abort_txns_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_txns_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_abort_txns_pargs::~ThriftHiveMetastore_abort_txns_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_abort_txns_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_txns_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_abort_txns_result::~ThriftHiveMetastore_abort_txns_result() noexcept { +} + +ThriftHiveMetastore_abort_txns_result::ThriftHiveMetastore_abort_txns_result() noexcept { +} + +uint32_t ThriftHiveMetastore_abort_txns_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_abort_txns_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_txns_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_abort_txns_presult::~ThriftHiveMetastore_abort_txns_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_abort_txns_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_commit_txn_args::~ThriftHiveMetastore_commit_txn_args() noexcept { +} + +ThriftHiveMetastore_commit_txn_args::ThriftHiveMetastore_commit_txn_args() noexcept { +} + +uint32_t ThriftHiveMetastore_commit_txn_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_commit_txn_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_commit_txn_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_commit_txn_pargs::~ThriftHiveMetastore_commit_txn_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_commit_txn_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_commit_txn_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_commit_txn_result::~ThriftHiveMetastore_commit_txn_result() noexcept { +} + +ThriftHiveMetastore_commit_txn_result::ThriftHiveMetastore_commit_txn_result() noexcept { +} + +uint32_t ThriftHiveMetastore_commit_txn_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_commit_txn_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_commit_txn_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_commit_txn_presult::~ThriftHiveMetastore_commit_txn_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_commit_txn_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_latest_txnid_in_conflict_args::~ThriftHiveMetastore_get_latest_txnid_in_conflict_args() noexcept { +} + +ThriftHiveMetastore_get_latest_txnid_in_conflict_args::ThriftHiveMetastore_get_latest_txnid_in_conflict_args() noexcept + : txnId(0) { +} + +uint32_t ThriftHiveMetastore_get_latest_txnid_in_conflict_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnId); + this->__isset.txnId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_latest_txnid_in_conflict_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_latest_txnid_in_conflict_args"); + + xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->txnId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_latest_txnid_in_conflict_pargs::~ThriftHiveMetastore_get_latest_txnid_in_conflict_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_latest_txnid_in_conflict_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_latest_txnid_in_conflict_pargs"); + + xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64((*(this->txnId))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_latest_txnid_in_conflict_result::~ThriftHiveMetastore_get_latest_txnid_in_conflict_result() noexcept { +} + +ThriftHiveMetastore_get_latest_txnid_in_conflict_result::ThriftHiveMetastore_get_latest_txnid_in_conflict_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_get_latest_txnid_in_conflict_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_latest_txnid_in_conflict_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_latest_txnid_in_conflict_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I64, 0); + xfer += oprot->writeI64(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_latest_txnid_in_conflict_presult::~ThriftHiveMetastore_get_latest_txnid_in_conflict_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_latest_txnid_in_conflict_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_repl_tbl_writeid_state_args::~ThriftHiveMetastore_repl_tbl_writeid_state_args() noexcept { +} + +ThriftHiveMetastore_repl_tbl_writeid_state_args::ThriftHiveMetastore_repl_tbl_writeid_state_args() noexcept { +} + +uint32_t ThriftHiveMetastore_repl_tbl_writeid_state_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_repl_tbl_writeid_state_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_repl_tbl_writeid_state_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_repl_tbl_writeid_state_pargs::~ThriftHiveMetastore_repl_tbl_writeid_state_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_repl_tbl_writeid_state_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_repl_tbl_writeid_state_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_repl_tbl_writeid_state_result::~ThriftHiveMetastore_repl_tbl_writeid_state_result() noexcept { +} + +ThriftHiveMetastore_repl_tbl_writeid_state_result::ThriftHiveMetastore_repl_tbl_writeid_state_result() noexcept { +} + +uint32_t ThriftHiveMetastore_repl_tbl_writeid_state_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_repl_tbl_writeid_state_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_repl_tbl_writeid_state_result"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_repl_tbl_writeid_state_presult::~ThriftHiveMetastore_repl_tbl_writeid_state_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_repl_tbl_writeid_state_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_valid_write_ids_args::~ThriftHiveMetastore_get_valid_write_ids_args() noexcept { +} + +ThriftHiveMetastore_get_valid_write_ids_args::ThriftHiveMetastore_get_valid_write_ids_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_valid_write_ids_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_valid_write_ids_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_valid_write_ids_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_valid_write_ids_pargs::~ThriftHiveMetastore_get_valid_write_ids_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_valid_write_ids_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_valid_write_ids_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_valid_write_ids_result::~ThriftHiveMetastore_get_valid_write_ids_result() noexcept { +} + +ThriftHiveMetastore_get_valid_write_ids_result::ThriftHiveMetastore_get_valid_write_ids_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_valid_write_ids_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_valid_write_ids_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_valid_write_ids_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_valid_write_ids_presult::~ThriftHiveMetastore_get_valid_write_ids_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_valid_write_ids_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_write_ids_to_min_history_args::~ThriftHiveMetastore_add_write_ids_to_min_history_args() noexcept { +} + +ThriftHiveMetastore_add_write_ids_to_min_history_args::ThriftHiveMetastore_add_write_ids_to_min_history_args() noexcept + : txnId(0) { +} + +uint32_t ThriftHiveMetastore_add_write_ids_to_min_history_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnId); + this->__isset.txnId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->writeIds.clear(); + uint32_t _size2570; + ::apache::thrift::protocol::TType _ktype2571; + ::apache::thrift::protocol::TType _vtype2572; + xfer += iprot->readMapBegin(_ktype2571, _vtype2572, _size2570); + uint32_t _i2574; + for (_i2574 = 0; _i2574 < _size2570; ++_i2574) + { + std::string _key2575; + xfer += iprot->readString(_key2575); + int64_t& _val2576 = this->writeIds[_key2575]; + xfer += iprot->readI64(_val2576); + } + xfer += iprot->readMapEnd(); + } + this->__isset.writeIds = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_write_ids_to_min_history_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_write_ids_to_min_history_args"); + + xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->txnId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("writeIds", ::apache::thrift::protocol::T_MAP, 2); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I64, static_cast(this->writeIds.size())); + std::map ::const_iterator _iter2577; + for (_iter2577 = this->writeIds.begin(); _iter2577 != this->writeIds.end(); ++_iter2577) + { + xfer += oprot->writeString(_iter2577->first); + xfer += oprot->writeI64(_iter2577->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_write_ids_to_min_history_pargs::~ThriftHiveMetastore_add_write_ids_to_min_history_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_write_ids_to_min_history_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_write_ids_to_min_history_pargs"); + + xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64((*(this->txnId))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("writeIds", ::apache::thrift::protocol::T_MAP, 2); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I64, static_cast((*(this->writeIds)).size())); + std::map ::const_iterator _iter2578; + for (_iter2578 = (*(this->writeIds)).begin(); _iter2578 != (*(this->writeIds)).end(); ++_iter2578) + { + xfer += oprot->writeString(_iter2578->first); + xfer += oprot->writeI64(_iter2578->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_write_ids_to_min_history_result::~ThriftHiveMetastore_add_write_ids_to_min_history_result() noexcept { +} + +ThriftHiveMetastore_add_write_ids_to_min_history_result::ThriftHiveMetastore_add_write_ids_to_min_history_result() noexcept { +} + +uint32_t ThriftHiveMetastore_add_write_ids_to_min_history_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_write_ids_to_min_history_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_write_ids_to_min_history_result"); + + if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_write_ids_to_min_history_presult::~ThriftHiveMetastore_add_write_ids_to_min_history_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_write_ids_to_min_history_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_allocate_table_write_ids_args::~ThriftHiveMetastore_allocate_table_write_ids_args() noexcept { +} + +ThriftHiveMetastore_allocate_table_write_ids_args::ThriftHiveMetastore_allocate_table_write_ids_args() noexcept { +} + +uint32_t ThriftHiveMetastore_allocate_table_write_ids_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_allocate_table_write_ids_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_allocate_table_write_ids_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_allocate_table_write_ids_pargs::~ThriftHiveMetastore_allocate_table_write_ids_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_allocate_table_write_ids_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_allocate_table_write_ids_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_allocate_table_write_ids_result::~ThriftHiveMetastore_allocate_table_write_ids_result() noexcept { +} + +ThriftHiveMetastore_allocate_table_write_ids_result::ThriftHiveMetastore_allocate_table_write_ids_result() noexcept { +} + +uint32_t ThriftHiveMetastore_allocate_table_write_ids_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_allocate_table_write_ids_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_allocate_table_write_ids_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_allocate_table_write_ids_presult::~ThriftHiveMetastore_allocate_table_write_ids_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_allocate_table_write_ids_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_max_allocated_table_write_id_args::~ThriftHiveMetastore_get_max_allocated_table_write_id_args() noexcept { +} + +ThriftHiveMetastore_get_max_allocated_table_write_id_args::ThriftHiveMetastore_get_max_allocated_table_write_id_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_max_allocated_table_write_id_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_max_allocated_table_write_id_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_max_allocated_table_write_id_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_max_allocated_table_write_id_pargs::~ThriftHiveMetastore_get_max_allocated_table_write_id_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_max_allocated_table_write_id_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_max_allocated_table_write_id_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_max_allocated_table_write_id_result::~ThriftHiveMetastore_get_max_allocated_table_write_id_result() noexcept { +} + +ThriftHiveMetastore_get_max_allocated_table_write_id_result::ThriftHiveMetastore_get_max_allocated_table_write_id_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_max_allocated_table_write_id_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_max_allocated_table_write_id_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_max_allocated_table_write_id_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_max_allocated_table_write_id_presult::~ThriftHiveMetastore_get_max_allocated_table_write_id_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_max_allocated_table_write_id_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_seed_write_id_args::~ThriftHiveMetastore_seed_write_id_args() noexcept { +} + +ThriftHiveMetastore_seed_write_id_args::ThriftHiveMetastore_seed_write_id_args() noexcept { +} + +uint32_t ThriftHiveMetastore_seed_write_id_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_seed_write_id_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_seed_write_id_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_seed_write_id_pargs::~ThriftHiveMetastore_seed_write_id_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_seed_write_id_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_seed_write_id_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_seed_write_id_result::~ThriftHiveMetastore_seed_write_id_result() noexcept { +} + +ThriftHiveMetastore_seed_write_id_result::ThriftHiveMetastore_seed_write_id_result() noexcept { +} + +uint32_t ThriftHiveMetastore_seed_write_id_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_seed_write_id_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_seed_write_id_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_seed_write_id_presult::~ThriftHiveMetastore_seed_write_id_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_seed_write_id_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_seed_txn_id_args::~ThriftHiveMetastore_seed_txn_id_args() noexcept { +} + +ThriftHiveMetastore_seed_txn_id_args::ThriftHiveMetastore_seed_txn_id_args() noexcept { +} + +uint32_t ThriftHiveMetastore_seed_txn_id_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_seed_txn_id_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_seed_txn_id_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_seed_txn_id_pargs::~ThriftHiveMetastore_seed_txn_id_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_seed_txn_id_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_seed_txn_id_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_seed_txn_id_result::~ThriftHiveMetastore_seed_txn_id_result() noexcept { +} + +ThriftHiveMetastore_seed_txn_id_result::ThriftHiveMetastore_seed_txn_id_result() noexcept { +} + +uint32_t ThriftHiveMetastore_seed_txn_id_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_seed_txn_id_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_seed_txn_id_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_seed_txn_id_presult::~ThriftHiveMetastore_seed_txn_id_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_seed_txn_id_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_lock_args::~ThriftHiveMetastore_lock_args() noexcept { +} + +ThriftHiveMetastore_lock_args::ThriftHiveMetastore_lock_args() noexcept { +} + +uint32_t ThriftHiveMetastore_lock_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_lock_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_lock_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_lock_pargs::~ThriftHiveMetastore_lock_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_lock_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_lock_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_lock_result::~ThriftHiveMetastore_lock_result() noexcept { +} + +ThriftHiveMetastore_lock_result::ThriftHiveMetastore_lock_result() noexcept { +} + +uint32_t ThriftHiveMetastore_lock_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_lock_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_lock_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_lock_presult::~ThriftHiveMetastore_lock_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_lock_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_check_lock_args::~ThriftHiveMetastore_check_lock_args() noexcept { +} + +ThriftHiveMetastore_check_lock_args::ThriftHiveMetastore_check_lock_args() noexcept { +} + +uint32_t ThriftHiveMetastore_check_lock_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_check_lock_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_check_lock_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_check_lock_pargs::~ThriftHiveMetastore_check_lock_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_check_lock_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_check_lock_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_check_lock_result::~ThriftHiveMetastore_check_lock_result() noexcept { +} + +ThriftHiveMetastore_check_lock_result::ThriftHiveMetastore_check_lock_result() noexcept { +} + +uint32_t ThriftHiveMetastore_check_lock_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_check_lock_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_check_lock_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_check_lock_presult::~ThriftHiveMetastore_check_lock_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_check_lock_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_unlock_args::~ThriftHiveMetastore_unlock_args() noexcept { +} + +ThriftHiveMetastore_unlock_args::ThriftHiveMetastore_unlock_args() noexcept { +} + +uint32_t ThriftHiveMetastore_unlock_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_unlock_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_unlock_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_unlock_pargs::~ThriftHiveMetastore_unlock_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_unlock_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_unlock_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_unlock_result::~ThriftHiveMetastore_unlock_result() noexcept { +} + +ThriftHiveMetastore_unlock_result::ThriftHiveMetastore_unlock_result() noexcept { +} + +uint32_t ThriftHiveMetastore_unlock_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_unlock_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_unlock_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_unlock_presult::~ThriftHiveMetastore_unlock_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_unlock_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_show_locks_args::~ThriftHiveMetastore_show_locks_args() noexcept { +} + +ThriftHiveMetastore_show_locks_args::ThriftHiveMetastore_show_locks_args() noexcept { +} + +uint32_t ThriftHiveMetastore_show_locks_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_show_locks_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_show_locks_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_show_locks_pargs::~ThriftHiveMetastore_show_locks_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_show_locks_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_show_locks_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_show_locks_result::~ThriftHiveMetastore_show_locks_result() noexcept { +} + +ThriftHiveMetastore_show_locks_result::ThriftHiveMetastore_show_locks_result() noexcept { +} + +uint32_t ThriftHiveMetastore_show_locks_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_show_locks_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_show_locks_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_show_locks_presult::~ThriftHiveMetastore_show_locks_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_show_locks_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_heartbeat_args::~ThriftHiveMetastore_heartbeat_args() noexcept { +} + +ThriftHiveMetastore_heartbeat_args::ThriftHiveMetastore_heartbeat_args() noexcept { +} + +uint32_t ThriftHiveMetastore_heartbeat_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ids.read(iprot); + this->__isset.ids = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_heartbeat_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_args"); + + xfer += oprot->writeFieldBegin("ids", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->ids.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_heartbeat_pargs::~ThriftHiveMetastore_heartbeat_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_heartbeat_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_pargs"); + + xfer += oprot->writeFieldBegin("ids", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->ids)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_heartbeat_result::~ThriftHiveMetastore_heartbeat_result() noexcept { +} + +ThriftHiveMetastore_heartbeat_result::ThriftHiveMetastore_heartbeat_result() noexcept { +} + +uint32_t ThriftHiveMetastore_heartbeat_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_heartbeat_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_heartbeat_presult::~ThriftHiveMetastore_heartbeat_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_heartbeat_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_heartbeat_txn_range_args::~ThriftHiveMetastore_heartbeat_txn_range_args() noexcept { +} + +ThriftHiveMetastore_heartbeat_txn_range_args::ThriftHiveMetastore_heartbeat_txn_range_args() noexcept { +} + +uint32_t ThriftHiveMetastore_heartbeat_txn_range_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->txns.read(iprot); + this->__isset.txns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_heartbeat_txn_range_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_txn_range_args"); + + xfer += oprot->writeFieldBegin("txns", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->txns.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_heartbeat_txn_range_pargs::~ThriftHiveMetastore_heartbeat_txn_range_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_heartbeat_txn_range_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_txn_range_pargs"); + + xfer += oprot->writeFieldBegin("txns", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->txns)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_heartbeat_txn_range_result::~ThriftHiveMetastore_heartbeat_txn_range_result() noexcept { +} + +ThriftHiveMetastore_heartbeat_txn_range_result::ThriftHiveMetastore_heartbeat_txn_range_result() noexcept { +} + +uint32_t ThriftHiveMetastore_heartbeat_txn_range_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_heartbeat_txn_range_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_txn_range_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_heartbeat_txn_range_presult::~ThriftHiveMetastore_heartbeat_txn_range_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_heartbeat_txn_range_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_compact_args::~ThriftHiveMetastore_compact_args() noexcept { +} + +ThriftHiveMetastore_compact_args::ThriftHiveMetastore_compact_args() noexcept { +} + +uint32_t ThriftHiveMetastore_compact_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_compact_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_compact_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_compact_pargs::~ThriftHiveMetastore_compact_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_compact_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_compact_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_compact_result::~ThriftHiveMetastore_compact_result() noexcept { +} + +ThriftHiveMetastore_compact_result::ThriftHiveMetastore_compact_result() noexcept { +} + +uint32_t ThriftHiveMetastore_compact_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_compact_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_compact_result"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_compact_presult::~ThriftHiveMetastore_compact_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_compact_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_compact2_args::~ThriftHiveMetastore_compact2_args() noexcept { +} + +ThriftHiveMetastore_compact2_args::ThriftHiveMetastore_compact2_args() noexcept { +} + +uint32_t ThriftHiveMetastore_compact2_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_compact2_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_compact2_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_compact2_pargs::~ThriftHiveMetastore_compact2_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_compact2_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_compact2_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_compact2_result::~ThriftHiveMetastore_compact2_result() noexcept { +} + +ThriftHiveMetastore_compact2_result::ThriftHiveMetastore_compact2_result() noexcept { +} + +uint32_t ThriftHiveMetastore_compact2_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_compact2_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_compact2_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_compact2_presult::~ThriftHiveMetastore_compact2_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_compact2_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_show_compact_args::~ThriftHiveMetastore_show_compact_args() noexcept { +} + +ThriftHiveMetastore_show_compact_args::ThriftHiveMetastore_show_compact_args() noexcept { +} + +uint32_t ThriftHiveMetastore_show_compact_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_show_compact_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_show_compact_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_show_compact_pargs::~ThriftHiveMetastore_show_compact_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_show_compact_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_show_compact_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_show_compact_result::~ThriftHiveMetastore_show_compact_result() noexcept { +} + +ThriftHiveMetastore_show_compact_result::ThriftHiveMetastore_show_compact_result() noexcept { +} + +uint32_t ThriftHiveMetastore_show_compact_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_show_compact_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_show_compact_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_show_compact_presult::~ThriftHiveMetastore_show_compact_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_show_compact_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_submit_for_cleanup_args::~ThriftHiveMetastore_submit_for_cleanup_args() noexcept { +} + +ThriftHiveMetastore_submit_for_cleanup_args::ThriftHiveMetastore_submit_for_cleanup_args() noexcept + : o2(0), + o3(0) { +} + +uint32_t ThriftHiveMetastore_submit_for_cleanup_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->o2); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->o3); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_submit_for_cleanup_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_submit_for_cleanup_args"); + + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->o2); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->o3); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_submit_for_cleanup_pargs::~ThriftHiveMetastore_submit_for_cleanup_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_submit_for_cleanup_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_submit_for_cleanup_pargs"); + + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->o1)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64((*(this->o2))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64((*(this->o3))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_submit_for_cleanup_result::~ThriftHiveMetastore_submit_for_cleanup_result() noexcept { +} + +ThriftHiveMetastore_submit_for_cleanup_result::ThriftHiveMetastore_submit_for_cleanup_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_submit_for_cleanup_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_submit_for_cleanup_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_submit_for_cleanup_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_submit_for_cleanup_presult::~ThriftHiveMetastore_submit_for_cleanup_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_submit_for_cleanup_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_dynamic_partitions_args::~ThriftHiveMetastore_add_dynamic_partitions_args() noexcept { +} + +ThriftHiveMetastore_add_dynamic_partitions_args::ThriftHiveMetastore_add_dynamic_partitions_args() noexcept { +} + +uint32_t ThriftHiveMetastore_add_dynamic_partitions_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_dynamic_partitions_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_dynamic_partitions_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_dynamic_partitions_pargs::~ThriftHiveMetastore_add_dynamic_partitions_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_dynamic_partitions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_dynamic_partitions_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_dynamic_partitions_result::~ThriftHiveMetastore_add_dynamic_partitions_result() noexcept { +} + +ThriftHiveMetastore_add_dynamic_partitions_result::ThriftHiveMetastore_add_dynamic_partitions_result() noexcept { +} + +uint32_t ThriftHiveMetastore_add_dynamic_partitions_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_dynamic_partitions_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_dynamic_partitions_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_dynamic_partitions_presult::~ThriftHiveMetastore_add_dynamic_partitions_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_dynamic_partitions_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_find_next_compact_args::~ThriftHiveMetastore_find_next_compact_args() noexcept { +} + +ThriftHiveMetastore_find_next_compact_args::ThriftHiveMetastore_find_next_compact_args() noexcept + : workerId() { +} + +uint32_t ThriftHiveMetastore_find_next_compact_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->workerId); + this->__isset.workerId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_find_next_compact_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_find_next_compact_args"); + + xfer += oprot->writeFieldBegin("workerId", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->workerId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_find_next_compact_pargs::~ThriftHiveMetastore_find_next_compact_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_find_next_compact_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_find_next_compact_pargs"); + + xfer += oprot->writeFieldBegin("workerId", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->workerId))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_find_next_compact_result::~ThriftHiveMetastore_find_next_compact_result() noexcept { +} + +ThriftHiveMetastore_find_next_compact_result::ThriftHiveMetastore_find_next_compact_result() noexcept { +} + +uint32_t ThriftHiveMetastore_find_next_compact_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_find_next_compact_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_find_next_compact_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_find_next_compact_presult::~ThriftHiveMetastore_find_next_compact_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_find_next_compact_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_find_next_compact2_args::~ThriftHiveMetastore_find_next_compact2_args() noexcept { +} + +ThriftHiveMetastore_find_next_compact2_args::ThriftHiveMetastore_find_next_compact2_args() noexcept { +} + +uint32_t ThriftHiveMetastore_find_next_compact2_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_find_next_compact2_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_find_next_compact2_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_find_next_compact2_pargs::~ThriftHiveMetastore_find_next_compact2_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_find_next_compact2_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_find_next_compact2_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_find_next_compact2_result::~ThriftHiveMetastore_find_next_compact2_result() noexcept { +} + +ThriftHiveMetastore_find_next_compact2_result::ThriftHiveMetastore_find_next_compact2_result() noexcept { +} + +uint32_t ThriftHiveMetastore_find_next_compact2_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_find_next_compact2_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_find_next_compact2_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_find_next_compact2_presult::~ThriftHiveMetastore_find_next_compact2_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_find_next_compact2_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_update_compactor_state_args::~ThriftHiveMetastore_update_compactor_state_args() noexcept { +} + +ThriftHiveMetastore_update_compactor_state_args::ThriftHiveMetastore_update_compactor_state_args() noexcept + : txn_id(0) { +} + +uint32_t ThriftHiveMetastore_update_compactor_state_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->cr.read(iprot); + this->__isset.cr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txn_id); + this->__isset.txn_id = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_update_compactor_state_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_compactor_state_args"); + + xfer += oprot->writeFieldBegin("cr", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->cr.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("txn_id", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->txn_id); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_compactor_state_pargs::~ThriftHiveMetastore_update_compactor_state_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_update_compactor_state_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_compactor_state_pargs"); + + xfer += oprot->writeFieldBegin("cr", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->cr)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("txn_id", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64((*(this->txn_id))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_compactor_state_result::~ThriftHiveMetastore_update_compactor_state_result() noexcept { +} + +ThriftHiveMetastore_update_compactor_state_result::ThriftHiveMetastore_update_compactor_state_result() noexcept { +} + +uint32_t ThriftHiveMetastore_update_compactor_state_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_update_compactor_state_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_compactor_state_result"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_compactor_state_presult::~ThriftHiveMetastore_update_compactor_state_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_update_compactor_state_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_find_columns_with_stats_args::~ThriftHiveMetastore_find_columns_with_stats_args() noexcept { +} + +ThriftHiveMetastore_find_columns_with_stats_args::ThriftHiveMetastore_find_columns_with_stats_args() noexcept { +} + +uint32_t ThriftHiveMetastore_find_columns_with_stats_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->cr.read(iprot); + this->__isset.cr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_find_columns_with_stats_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_find_columns_with_stats_args"); + + xfer += oprot->writeFieldBegin("cr", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->cr.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_find_columns_with_stats_pargs::~ThriftHiveMetastore_find_columns_with_stats_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_find_columns_with_stats_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_find_columns_with_stats_pargs"); + + xfer += oprot->writeFieldBegin("cr", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->cr)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_find_columns_with_stats_result::~ThriftHiveMetastore_find_columns_with_stats_result() noexcept { +} + +ThriftHiveMetastore_find_columns_with_stats_result::ThriftHiveMetastore_find_columns_with_stats_result() noexcept { +} + +uint32_t ThriftHiveMetastore_find_columns_with_stats_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2579; + ::apache::thrift::protocol::TType _etype2582; + xfer += iprot->readListBegin(_etype2582, _size2579); + this->success.resize(_size2579); + uint32_t _i2583; + for (_i2583 = 0; _i2583 < _size2579; ++_i2583) + { + xfer += iprot->readString(this->success[_i2583]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_find_columns_with_stats_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_find_columns_with_stats_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::vector ::const_iterator _iter2584; + for (_iter2584 = this->success.begin(); _iter2584 != this->success.end(); ++_iter2584) + { + xfer += oprot->writeString((*_iter2584)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_find_columns_with_stats_presult::~ThriftHiveMetastore_find_columns_with_stats_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_find_columns_with_stats_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2585; + ::apache::thrift::protocol::TType _etype2588; + xfer += iprot->readListBegin(_etype2588, _size2585); + (*(this->success)).resize(_size2585); + uint32_t _i2589; + for (_i2589 = 0; _i2589 < _size2585; ++_i2589) + { + xfer += iprot->readString((*(this->success))[_i2589]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_mark_cleaned_args::~ThriftHiveMetastore_mark_cleaned_args() noexcept { +} + +ThriftHiveMetastore_mark_cleaned_args::ThriftHiveMetastore_mark_cleaned_args() noexcept { +} + +uint32_t ThriftHiveMetastore_mark_cleaned_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->cr.read(iprot); + this->__isset.cr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_mark_cleaned_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_mark_cleaned_args"); + + xfer += oprot->writeFieldBegin("cr", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->cr.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_mark_cleaned_pargs::~ThriftHiveMetastore_mark_cleaned_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_mark_cleaned_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_mark_cleaned_pargs"); + + xfer += oprot->writeFieldBegin("cr", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->cr)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_mark_cleaned_result::~ThriftHiveMetastore_mark_cleaned_result() noexcept { +} + +ThriftHiveMetastore_mark_cleaned_result::ThriftHiveMetastore_mark_cleaned_result() noexcept { +} + +uint32_t ThriftHiveMetastore_mark_cleaned_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_mark_cleaned_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_mark_cleaned_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_mark_cleaned_presult::~ThriftHiveMetastore_mark_cleaned_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_mark_cleaned_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_mark_compacted_args::~ThriftHiveMetastore_mark_compacted_args() noexcept { +} + +ThriftHiveMetastore_mark_compacted_args::ThriftHiveMetastore_mark_compacted_args() noexcept { +} + +uint32_t ThriftHiveMetastore_mark_compacted_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->cr.read(iprot); + this->__isset.cr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_mark_compacted_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_mark_compacted_args"); + + xfer += oprot->writeFieldBegin("cr", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->cr.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_mark_compacted_pargs::~ThriftHiveMetastore_mark_compacted_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_mark_compacted_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_mark_compacted_pargs"); + + xfer += oprot->writeFieldBegin("cr", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->cr)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_mark_compacted_result::~ThriftHiveMetastore_mark_compacted_result() noexcept { +} + +ThriftHiveMetastore_mark_compacted_result::ThriftHiveMetastore_mark_compacted_result() noexcept { +} + +uint32_t ThriftHiveMetastore_mark_compacted_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_mark_compacted_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_mark_compacted_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_mark_compacted_presult::~ThriftHiveMetastore_mark_compacted_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_mark_compacted_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_mark_failed_args::~ThriftHiveMetastore_mark_failed_args() noexcept { +} + +ThriftHiveMetastore_mark_failed_args::ThriftHiveMetastore_mark_failed_args() noexcept { +} + +uint32_t ThriftHiveMetastore_mark_failed_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->cr.read(iprot); + this->__isset.cr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_mark_failed_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_mark_failed_args"); + + xfer += oprot->writeFieldBegin("cr", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->cr.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_mark_failed_pargs::~ThriftHiveMetastore_mark_failed_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_mark_failed_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_mark_failed_pargs"); + + xfer += oprot->writeFieldBegin("cr", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->cr)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_mark_failed_result::~ThriftHiveMetastore_mark_failed_result() noexcept { +} + +ThriftHiveMetastore_mark_failed_result::ThriftHiveMetastore_mark_failed_result() noexcept { +} + +uint32_t ThriftHiveMetastore_mark_failed_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_mark_failed_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_mark_failed_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_mark_failed_presult::~ThriftHiveMetastore_mark_failed_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_mark_failed_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_mark_refused_args::~ThriftHiveMetastore_mark_refused_args() noexcept { +} + +ThriftHiveMetastore_mark_refused_args::ThriftHiveMetastore_mark_refused_args() noexcept { +} + +uint32_t ThriftHiveMetastore_mark_refused_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->cr.read(iprot); + this->__isset.cr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_mark_refused_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_mark_refused_args"); + + xfer += oprot->writeFieldBegin("cr", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->cr.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_mark_refused_pargs::~ThriftHiveMetastore_mark_refused_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_mark_refused_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_mark_refused_pargs"); + + xfer += oprot->writeFieldBegin("cr", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->cr)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_mark_refused_result::~ThriftHiveMetastore_mark_refused_result() noexcept { +} + +ThriftHiveMetastore_mark_refused_result::ThriftHiveMetastore_mark_refused_result() noexcept { +} + +uint32_t ThriftHiveMetastore_mark_refused_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_mark_refused_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_mark_refused_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_mark_refused_presult::~ThriftHiveMetastore_mark_refused_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_mark_refused_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_update_compaction_metrics_data_args::~ThriftHiveMetastore_update_compaction_metrics_data_args() noexcept { +} + +ThriftHiveMetastore_update_compaction_metrics_data_args::ThriftHiveMetastore_update_compaction_metrics_data_args() noexcept { +} + +uint32_t ThriftHiveMetastore_update_compaction_metrics_data_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->data.read(iprot); + this->__isset.data = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_update_compaction_metrics_data_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_compaction_metrics_data_args"); + + xfer += oprot->writeFieldBegin("data", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->data.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_compaction_metrics_data_pargs::~ThriftHiveMetastore_update_compaction_metrics_data_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_update_compaction_metrics_data_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_compaction_metrics_data_pargs"); + + xfer += oprot->writeFieldBegin("data", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->data)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_compaction_metrics_data_result::~ThriftHiveMetastore_update_compaction_metrics_data_result() noexcept { +} + +ThriftHiveMetastore_update_compaction_metrics_data_result::ThriftHiveMetastore_update_compaction_metrics_data_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_update_compaction_metrics_data_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_update_compaction_metrics_data_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_compaction_metrics_data_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_update_compaction_metrics_data_presult::~ThriftHiveMetastore_update_compaction_metrics_data_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_update_compaction_metrics_data_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_remove_compaction_metrics_data_args::~ThriftHiveMetastore_remove_compaction_metrics_data_args() noexcept { +} + +ThriftHiveMetastore_remove_compaction_metrics_data_args::ThriftHiveMetastore_remove_compaction_metrics_data_args() noexcept { +} + +uint32_t ThriftHiveMetastore_remove_compaction_metrics_data_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_remove_compaction_metrics_data_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_remove_compaction_metrics_data_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_remove_compaction_metrics_data_pargs::~ThriftHiveMetastore_remove_compaction_metrics_data_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_remove_compaction_metrics_data_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_remove_compaction_metrics_data_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_remove_compaction_metrics_data_result::~ThriftHiveMetastore_remove_compaction_metrics_data_result() noexcept { +} + +ThriftHiveMetastore_remove_compaction_metrics_data_result::ThriftHiveMetastore_remove_compaction_metrics_data_result() noexcept { +} + +uint32_t ThriftHiveMetastore_remove_compaction_metrics_data_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_remove_compaction_metrics_data_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_remove_compaction_metrics_data_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_remove_compaction_metrics_data_presult::~ThriftHiveMetastore_remove_compaction_metrics_data_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_remove_compaction_metrics_data_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_set_hadoop_jobid_args::~ThriftHiveMetastore_set_hadoop_jobid_args() noexcept { +} + +ThriftHiveMetastore_set_hadoop_jobid_args::ThriftHiveMetastore_set_hadoop_jobid_args() noexcept + : jobId(), + cq_id(0) { +} + +uint32_t ThriftHiveMetastore_set_hadoop_jobid_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->jobId); + this->__isset.jobId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->cq_id); + this->__isset.cq_id = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_set_hadoop_jobid_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_set_hadoop_jobid_args"); + + xfer += oprot->writeFieldBegin("jobId", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->jobId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("cq_id", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->cq_id); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_set_hadoop_jobid_pargs::~ThriftHiveMetastore_set_hadoop_jobid_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_set_hadoop_jobid_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_set_hadoop_jobid_pargs"); + + xfer += oprot->writeFieldBegin("jobId", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->jobId))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("cq_id", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64((*(this->cq_id))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_set_hadoop_jobid_result::~ThriftHiveMetastore_set_hadoop_jobid_result() noexcept { +} + +ThriftHiveMetastore_set_hadoop_jobid_result::ThriftHiveMetastore_set_hadoop_jobid_result() noexcept { +} + +uint32_t ThriftHiveMetastore_set_hadoop_jobid_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_set_hadoop_jobid_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_set_hadoop_jobid_result"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_set_hadoop_jobid_presult::~ThriftHiveMetastore_set_hadoop_jobid_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_set_hadoop_jobid_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_latest_committed_compaction_info_args::~ThriftHiveMetastore_get_latest_committed_compaction_info_args() noexcept { +} + +ThriftHiveMetastore_get_latest_committed_compaction_info_args::ThriftHiveMetastore_get_latest_committed_compaction_info_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_latest_committed_compaction_info_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_latest_committed_compaction_info_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_latest_committed_compaction_info_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_latest_committed_compaction_info_pargs::~ThriftHiveMetastore_get_latest_committed_compaction_info_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_latest_committed_compaction_info_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_latest_committed_compaction_info_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_latest_committed_compaction_info_result::~ThriftHiveMetastore_get_latest_committed_compaction_info_result() noexcept { +} + +ThriftHiveMetastore_get_latest_committed_compaction_info_result::ThriftHiveMetastore_get_latest_committed_compaction_info_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_latest_committed_compaction_info_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_latest_committed_compaction_info_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_latest_committed_compaction_info_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_latest_committed_compaction_info_presult::~ThriftHiveMetastore_get_latest_committed_compaction_info_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_latest_committed_compaction_info_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_next_notification_args::~ThriftHiveMetastore_get_next_notification_args() noexcept { +} + +ThriftHiveMetastore_get_next_notification_args::ThriftHiveMetastore_get_next_notification_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_next_notification_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_next_notification_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_next_notification_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_next_notification_pargs::~ThriftHiveMetastore_get_next_notification_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_next_notification_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_next_notification_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_next_notification_result::~ThriftHiveMetastore_get_next_notification_result() noexcept { +} + +ThriftHiveMetastore_get_next_notification_result::ThriftHiveMetastore_get_next_notification_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_next_notification_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_next_notification_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_next_notification_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_next_notification_presult::~ThriftHiveMetastore_get_next_notification_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_next_notification_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_current_notificationEventId_args::~ThriftHiveMetastore_get_current_notificationEventId_args() noexcept { +} + +ThriftHiveMetastore_get_current_notificationEventId_args::ThriftHiveMetastore_get_current_notificationEventId_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_current_notificationEventId_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_current_notificationEventId_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_current_notificationEventId_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_current_notificationEventId_pargs::~ThriftHiveMetastore_get_current_notificationEventId_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_current_notificationEventId_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_current_notificationEventId_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_current_notificationEventId_result::~ThriftHiveMetastore_get_current_notificationEventId_result() noexcept { +} + +ThriftHiveMetastore_get_current_notificationEventId_result::ThriftHiveMetastore_get_current_notificationEventId_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_current_notificationEventId_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_current_notificationEventId_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_current_notificationEventId_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_current_notificationEventId_presult::~ThriftHiveMetastore_get_current_notificationEventId_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_current_notificationEventId_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_notification_events_count_args::~ThriftHiveMetastore_get_notification_events_count_args() noexcept { +} + +ThriftHiveMetastore_get_notification_events_count_args::ThriftHiveMetastore_get_notification_events_count_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_notification_events_count_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_notification_events_count_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_notification_events_count_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_notification_events_count_pargs::~ThriftHiveMetastore_get_notification_events_count_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_notification_events_count_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_notification_events_count_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_notification_events_count_result::~ThriftHiveMetastore_get_notification_events_count_result() noexcept { +} + +ThriftHiveMetastore_get_notification_events_count_result::ThriftHiveMetastore_get_notification_events_count_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_notification_events_count_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_notification_events_count_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_notification_events_count_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_notification_events_count_presult::~ThriftHiveMetastore_get_notification_events_count_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_notification_events_count_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_fire_listener_event_args::~ThriftHiveMetastore_fire_listener_event_args() noexcept { +} + +ThriftHiveMetastore_fire_listener_event_args::ThriftHiveMetastore_fire_listener_event_args() noexcept { +} + +uint32_t ThriftHiveMetastore_fire_listener_event_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_fire_listener_event_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_fire_listener_event_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_fire_listener_event_pargs::~ThriftHiveMetastore_fire_listener_event_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_fire_listener_event_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_fire_listener_event_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_fire_listener_event_result::~ThriftHiveMetastore_fire_listener_event_result() noexcept { +} + +ThriftHiveMetastore_fire_listener_event_result::ThriftHiveMetastore_fire_listener_event_result() noexcept { +} + +uint32_t ThriftHiveMetastore_fire_listener_event_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_fire_listener_event_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_fire_listener_event_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_fire_listener_event_presult::~ThriftHiveMetastore_fire_listener_event_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_fire_listener_event_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_flushCache_args::~ThriftHiveMetastore_flushCache_args() noexcept { +} + +ThriftHiveMetastore_flushCache_args::ThriftHiveMetastore_flushCache_args() noexcept { +} + +uint32_t ThriftHiveMetastore_flushCache_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_flushCache_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_flushCache_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_flushCache_pargs::~ThriftHiveMetastore_flushCache_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_flushCache_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_flushCache_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_flushCache_result::~ThriftHiveMetastore_flushCache_result() noexcept { +} + +ThriftHiveMetastore_flushCache_result::ThriftHiveMetastore_flushCache_result() noexcept { +} + +uint32_t ThriftHiveMetastore_flushCache_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_flushCache_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_flushCache_result"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_flushCache_presult::~ThriftHiveMetastore_flushCache_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_flushCache_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_write_notification_log_args::~ThriftHiveMetastore_add_write_notification_log_args() noexcept { +} + +ThriftHiveMetastore_add_write_notification_log_args::ThriftHiveMetastore_add_write_notification_log_args() noexcept { +} + +uint32_t ThriftHiveMetastore_add_write_notification_log_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_write_notification_log_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_write_notification_log_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_write_notification_log_pargs::~ThriftHiveMetastore_add_write_notification_log_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_write_notification_log_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_write_notification_log_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_write_notification_log_result::~ThriftHiveMetastore_add_write_notification_log_result() noexcept { +} + +ThriftHiveMetastore_add_write_notification_log_result::ThriftHiveMetastore_add_write_notification_log_result() noexcept { +} + +uint32_t ThriftHiveMetastore_add_write_notification_log_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_write_notification_log_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_write_notification_log_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_write_notification_log_presult::~ThriftHiveMetastore_add_write_notification_log_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_write_notification_log_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_write_notification_log_in_batch_args::~ThriftHiveMetastore_add_write_notification_log_in_batch_args() noexcept { +} + +ThriftHiveMetastore_add_write_notification_log_in_batch_args::ThriftHiveMetastore_add_write_notification_log_in_batch_args() noexcept { +} + +uint32_t ThriftHiveMetastore_add_write_notification_log_in_batch_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_write_notification_log_in_batch_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_write_notification_log_in_batch_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_write_notification_log_in_batch_pargs::~ThriftHiveMetastore_add_write_notification_log_in_batch_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_write_notification_log_in_batch_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_write_notification_log_in_batch_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_write_notification_log_in_batch_result::~ThriftHiveMetastore_add_write_notification_log_in_batch_result() noexcept { +} + +ThriftHiveMetastore_add_write_notification_log_in_batch_result::ThriftHiveMetastore_add_write_notification_log_in_batch_result() noexcept { +} + +uint32_t ThriftHiveMetastore_add_write_notification_log_in_batch_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_write_notification_log_in_batch_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_write_notification_log_in_batch_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_write_notification_log_in_batch_presult::~ThriftHiveMetastore_add_write_notification_log_in_batch_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_write_notification_log_in_batch_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_cm_recycle_args::~ThriftHiveMetastore_cm_recycle_args() noexcept { +} + +ThriftHiveMetastore_cm_recycle_args::ThriftHiveMetastore_cm_recycle_args() noexcept { +} + +uint32_t ThriftHiveMetastore_cm_recycle_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_cm_recycle_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cm_recycle_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_cm_recycle_pargs::~ThriftHiveMetastore_cm_recycle_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_cm_recycle_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cm_recycle_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_cm_recycle_result::~ThriftHiveMetastore_cm_recycle_result() noexcept { +} + +ThriftHiveMetastore_cm_recycle_result::ThriftHiveMetastore_cm_recycle_result() noexcept { +} + +uint32_t ThriftHiveMetastore_cm_recycle_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_cm_recycle_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cm_recycle_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_cm_recycle_presult::~ThriftHiveMetastore_cm_recycle_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_cm_recycle_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_file_metadata_by_expr_args::~ThriftHiveMetastore_get_file_metadata_by_expr_args() noexcept { +} + +ThriftHiveMetastore_get_file_metadata_by_expr_args::ThriftHiveMetastore_get_file_metadata_by_expr_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_file_metadata_by_expr_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_file_metadata_by_expr_pargs::~ThriftHiveMetastore_get_file_metadata_by_expr_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_file_metadata_by_expr_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_file_metadata_by_expr_result::~ThriftHiveMetastore_get_file_metadata_by_expr_result() noexcept { +} + +ThriftHiveMetastore_get_file_metadata_by_expr_result::ThriftHiveMetastore_get_file_metadata_by_expr_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_file_metadata_by_expr_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_file_metadata_by_expr_presult::~ThriftHiveMetastore_get_file_metadata_by_expr_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_file_metadata_args::~ThriftHiveMetastore_get_file_metadata_args() noexcept { +} + +ThriftHiveMetastore_get_file_metadata_args::ThriftHiveMetastore_get_file_metadata_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_file_metadata_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_file_metadata_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_file_metadata_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_file_metadata_pargs::~ThriftHiveMetastore_get_file_metadata_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_file_metadata_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_file_metadata_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_file_metadata_result::~ThriftHiveMetastore_get_file_metadata_result() noexcept { +} + +ThriftHiveMetastore_get_file_metadata_result::ThriftHiveMetastore_get_file_metadata_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_file_metadata_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_file_metadata_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_file_metadata_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_file_metadata_presult::~ThriftHiveMetastore_get_file_metadata_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_file_metadata_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_put_file_metadata_args::~ThriftHiveMetastore_put_file_metadata_args() noexcept { +} + +ThriftHiveMetastore_put_file_metadata_args::ThriftHiveMetastore_put_file_metadata_args() noexcept { +} + +uint32_t ThriftHiveMetastore_put_file_metadata_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_put_file_metadata_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_put_file_metadata_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_put_file_metadata_pargs::~ThriftHiveMetastore_put_file_metadata_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_put_file_metadata_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_put_file_metadata_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_put_file_metadata_result::~ThriftHiveMetastore_put_file_metadata_result() noexcept { +} + +ThriftHiveMetastore_put_file_metadata_result::ThriftHiveMetastore_put_file_metadata_result() noexcept { +} + +uint32_t ThriftHiveMetastore_put_file_metadata_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_put_file_metadata_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_put_file_metadata_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_put_file_metadata_presult::~ThriftHiveMetastore_put_file_metadata_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_put_file_metadata_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_clear_file_metadata_args::~ThriftHiveMetastore_clear_file_metadata_args() noexcept { +} + +ThriftHiveMetastore_clear_file_metadata_args::ThriftHiveMetastore_clear_file_metadata_args() noexcept { +} + +uint32_t ThriftHiveMetastore_clear_file_metadata_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_clear_file_metadata_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_clear_file_metadata_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_clear_file_metadata_pargs::~ThriftHiveMetastore_clear_file_metadata_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_clear_file_metadata_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_clear_file_metadata_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_clear_file_metadata_result::~ThriftHiveMetastore_clear_file_metadata_result() noexcept { +} + +ThriftHiveMetastore_clear_file_metadata_result::ThriftHiveMetastore_clear_file_metadata_result() noexcept { +} + +uint32_t ThriftHiveMetastore_clear_file_metadata_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_clear_file_metadata_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_clear_file_metadata_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_clear_file_metadata_presult::~ThriftHiveMetastore_clear_file_metadata_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_clear_file_metadata_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_cache_file_metadata_args::~ThriftHiveMetastore_cache_file_metadata_args() noexcept { +} + +ThriftHiveMetastore_cache_file_metadata_args::ThriftHiveMetastore_cache_file_metadata_args() noexcept { +} + +uint32_t ThriftHiveMetastore_cache_file_metadata_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_cache_file_metadata_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cache_file_metadata_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_cache_file_metadata_pargs::~ThriftHiveMetastore_cache_file_metadata_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_cache_file_metadata_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cache_file_metadata_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_cache_file_metadata_result::~ThriftHiveMetastore_cache_file_metadata_result() noexcept { +} + +ThriftHiveMetastore_cache_file_metadata_result::ThriftHiveMetastore_cache_file_metadata_result() noexcept { +} + +uint32_t ThriftHiveMetastore_cache_file_metadata_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_cache_file_metadata_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cache_file_metadata_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_cache_file_metadata_presult::~ThriftHiveMetastore_cache_file_metadata_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_cache_file_metadata_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_metastore_db_uuid_args::~ThriftHiveMetastore_get_metastore_db_uuid_args() noexcept { +} + +ThriftHiveMetastore_get_metastore_db_uuid_args::ThriftHiveMetastore_get_metastore_db_uuid_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_metastore_db_uuid_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_metastore_db_uuid_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_metastore_db_uuid_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_metastore_db_uuid_pargs::~ThriftHiveMetastore_get_metastore_db_uuid_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_metastore_db_uuid_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_metastore_db_uuid_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_metastore_db_uuid_result::~ThriftHiveMetastore_get_metastore_db_uuid_result() noexcept { +} + +ThriftHiveMetastore_get_metastore_db_uuid_result::ThriftHiveMetastore_get_metastore_db_uuid_result() noexcept + : success() { +} + +uint32_t ThriftHiveMetastore_get_metastore_db_uuid_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_metastore_db_uuid_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_metastore_db_uuid_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0); + xfer += oprot->writeString(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_metastore_db_uuid_presult::~ThriftHiveMetastore_get_metastore_db_uuid_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_metastore_db_uuid_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_create_resource_plan_args::~ThriftHiveMetastore_create_resource_plan_args() noexcept { +} + +ThriftHiveMetastore_create_resource_plan_args::ThriftHiveMetastore_create_resource_plan_args() noexcept { +} + +uint32_t ThriftHiveMetastore_create_resource_plan_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_resource_plan_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_resource_plan_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_resource_plan_pargs::~ThriftHiveMetastore_create_resource_plan_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_resource_plan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_resource_plan_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_resource_plan_result::~ThriftHiveMetastore_create_resource_plan_result() noexcept { +} + +ThriftHiveMetastore_create_resource_plan_result::ThriftHiveMetastore_create_resource_plan_result() noexcept { +} + +uint32_t ThriftHiveMetastore_create_resource_plan_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_resource_plan_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_resource_plan_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_resource_plan_presult::~ThriftHiveMetastore_create_resource_plan_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_resource_plan_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_resource_plan_args::~ThriftHiveMetastore_get_resource_plan_args() noexcept { +} + +ThriftHiveMetastore_get_resource_plan_args::ThriftHiveMetastore_get_resource_plan_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_resource_plan_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_resource_plan_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_resource_plan_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_resource_plan_pargs::~ThriftHiveMetastore_get_resource_plan_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_resource_plan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_resource_plan_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_resource_plan_result::~ThriftHiveMetastore_get_resource_plan_result() noexcept { +} + +ThriftHiveMetastore_get_resource_plan_result::ThriftHiveMetastore_get_resource_plan_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_resource_plan_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_resource_plan_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_resource_plan_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_resource_plan_presult::~ThriftHiveMetastore_get_resource_plan_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_resource_plan_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_active_resource_plan_args::~ThriftHiveMetastore_get_active_resource_plan_args() noexcept { +} + +ThriftHiveMetastore_get_active_resource_plan_args::ThriftHiveMetastore_get_active_resource_plan_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_active_resource_plan_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_active_resource_plan_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_active_resource_plan_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_active_resource_plan_pargs::~ThriftHiveMetastore_get_active_resource_plan_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_active_resource_plan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_active_resource_plan_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_active_resource_plan_result::~ThriftHiveMetastore_get_active_resource_plan_result() noexcept { +} + +ThriftHiveMetastore_get_active_resource_plan_result::ThriftHiveMetastore_get_active_resource_plan_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_active_resource_plan_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_active_resource_plan_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_active_resource_plan_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_active_resource_plan_presult::~ThriftHiveMetastore_get_active_resource_plan_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_active_resource_plan_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_all_resource_plans_args::~ThriftHiveMetastore_get_all_resource_plans_args() noexcept { +} + +ThriftHiveMetastore_get_all_resource_plans_args::ThriftHiveMetastore_get_all_resource_plans_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_all_resource_plans_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_all_resource_plans_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_resource_plans_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_resource_plans_pargs::~ThriftHiveMetastore_get_all_resource_plans_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_all_resource_plans_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_resource_plans_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_resource_plans_result::~ThriftHiveMetastore_get_all_resource_plans_result() noexcept { +} + +ThriftHiveMetastore_get_all_resource_plans_result::ThriftHiveMetastore_get_all_resource_plans_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_all_resource_plans_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_all_resource_plans_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_resource_plans_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_resource_plans_presult::~ThriftHiveMetastore_get_all_resource_plans_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_all_resource_plans_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_alter_resource_plan_args::~ThriftHiveMetastore_alter_resource_plan_args() noexcept { +} + +ThriftHiveMetastore_alter_resource_plan_args::ThriftHiveMetastore_alter_resource_plan_args() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_resource_plan_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_resource_plan_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_resource_plan_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_resource_plan_pargs::~ThriftHiveMetastore_alter_resource_plan_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_resource_plan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_resource_plan_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_resource_plan_result::~ThriftHiveMetastore_alter_resource_plan_result() noexcept { +} + +ThriftHiveMetastore_alter_resource_plan_result::ThriftHiveMetastore_alter_resource_plan_result() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_resource_plan_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_resource_plan_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_resource_plan_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_resource_plan_presult::~ThriftHiveMetastore_alter_resource_plan_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_resource_plan_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_validate_resource_plan_args::~ThriftHiveMetastore_validate_resource_plan_args() noexcept { +} + +ThriftHiveMetastore_validate_resource_plan_args::ThriftHiveMetastore_validate_resource_plan_args() noexcept { +} + +uint32_t ThriftHiveMetastore_validate_resource_plan_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_validate_resource_plan_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_validate_resource_plan_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_validate_resource_plan_pargs::~ThriftHiveMetastore_validate_resource_plan_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_validate_resource_plan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_validate_resource_plan_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_validate_resource_plan_result::~ThriftHiveMetastore_validate_resource_plan_result() noexcept { +} + +ThriftHiveMetastore_validate_resource_plan_result::ThriftHiveMetastore_validate_resource_plan_result() noexcept { +} + +uint32_t ThriftHiveMetastore_validate_resource_plan_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_validate_resource_plan_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_validate_resource_plan_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_validate_resource_plan_presult::~ThriftHiveMetastore_validate_resource_plan_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_validate_resource_plan_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_resource_plan_args::~ThriftHiveMetastore_drop_resource_plan_args() noexcept { +} + +ThriftHiveMetastore_drop_resource_plan_args::ThriftHiveMetastore_drop_resource_plan_args() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_resource_plan_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_resource_plan_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_resource_plan_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_resource_plan_pargs::~ThriftHiveMetastore_drop_resource_plan_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_resource_plan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_resource_plan_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_resource_plan_result::~ThriftHiveMetastore_drop_resource_plan_result() noexcept { +} + +ThriftHiveMetastore_drop_resource_plan_result::ThriftHiveMetastore_drop_resource_plan_result() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_resource_plan_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_resource_plan_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_resource_plan_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_resource_plan_presult::~ThriftHiveMetastore_drop_resource_plan_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_resource_plan_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_create_wm_trigger_args::~ThriftHiveMetastore_create_wm_trigger_args() noexcept { +} + +ThriftHiveMetastore_create_wm_trigger_args::ThriftHiveMetastore_create_wm_trigger_args() noexcept { +} + +uint32_t ThriftHiveMetastore_create_wm_trigger_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_wm_trigger_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_wm_trigger_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_wm_trigger_pargs::~ThriftHiveMetastore_create_wm_trigger_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_wm_trigger_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_wm_trigger_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_wm_trigger_result::~ThriftHiveMetastore_create_wm_trigger_result() noexcept { +} + +ThriftHiveMetastore_create_wm_trigger_result::ThriftHiveMetastore_create_wm_trigger_result() noexcept { +} + +uint32_t ThriftHiveMetastore_create_wm_trigger_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_wm_trigger_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_wm_trigger_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_wm_trigger_presult::~ThriftHiveMetastore_create_wm_trigger_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_wm_trigger_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_alter_wm_trigger_args::~ThriftHiveMetastore_alter_wm_trigger_args() noexcept { +} + +ThriftHiveMetastore_alter_wm_trigger_args::ThriftHiveMetastore_alter_wm_trigger_args() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_wm_trigger_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_wm_trigger_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_wm_trigger_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_wm_trigger_pargs::~ThriftHiveMetastore_alter_wm_trigger_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_wm_trigger_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_wm_trigger_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_wm_trigger_result::~ThriftHiveMetastore_alter_wm_trigger_result() noexcept { +} + +ThriftHiveMetastore_alter_wm_trigger_result::ThriftHiveMetastore_alter_wm_trigger_result() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_wm_trigger_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_wm_trigger_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_wm_trigger_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_wm_trigger_presult::~ThriftHiveMetastore_alter_wm_trigger_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_wm_trigger_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_wm_trigger_args::~ThriftHiveMetastore_drop_wm_trigger_args() noexcept { +} + +ThriftHiveMetastore_drop_wm_trigger_args::ThriftHiveMetastore_drop_wm_trigger_args() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_wm_trigger_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_wm_trigger_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_wm_trigger_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_wm_trigger_pargs::~ThriftHiveMetastore_drop_wm_trigger_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_wm_trigger_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_wm_trigger_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_wm_trigger_result::~ThriftHiveMetastore_drop_wm_trigger_result() noexcept { +} + +ThriftHiveMetastore_drop_wm_trigger_result::ThriftHiveMetastore_drop_wm_trigger_result() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_wm_trigger_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_wm_trigger_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_wm_trigger_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_wm_trigger_presult::~ThriftHiveMetastore_drop_wm_trigger_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_wm_trigger_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_triggers_for_resourceplan_args::~ThriftHiveMetastore_get_triggers_for_resourceplan_args() noexcept { +} + +ThriftHiveMetastore_get_triggers_for_resourceplan_args::ThriftHiveMetastore_get_triggers_for_resourceplan_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_triggers_for_resourceplan_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_triggers_for_resourceplan_pargs::~ThriftHiveMetastore_get_triggers_for_resourceplan_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_triggers_for_resourceplan_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_triggers_for_resourceplan_result::~ThriftHiveMetastore_get_triggers_for_resourceplan_result() noexcept { +} + +ThriftHiveMetastore_get_triggers_for_resourceplan_result::ThriftHiveMetastore_get_triggers_for_resourceplan_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_triggers_for_resourceplan_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_triggers_for_resourceplan_presult::~ThriftHiveMetastore_get_triggers_for_resourceplan_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_create_wm_pool_args::~ThriftHiveMetastore_create_wm_pool_args() noexcept { +} + +ThriftHiveMetastore_create_wm_pool_args::ThriftHiveMetastore_create_wm_pool_args() noexcept { +} + +uint32_t ThriftHiveMetastore_create_wm_pool_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_wm_pool_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_wm_pool_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_wm_pool_pargs::~ThriftHiveMetastore_create_wm_pool_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_wm_pool_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_wm_pool_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_wm_pool_result::~ThriftHiveMetastore_create_wm_pool_result() noexcept { +} + +ThriftHiveMetastore_create_wm_pool_result::ThriftHiveMetastore_create_wm_pool_result() noexcept { +} + +uint32_t ThriftHiveMetastore_create_wm_pool_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_wm_pool_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_wm_pool_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_wm_pool_presult::~ThriftHiveMetastore_create_wm_pool_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_wm_pool_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_alter_wm_pool_args::~ThriftHiveMetastore_alter_wm_pool_args() noexcept { +} + +ThriftHiveMetastore_alter_wm_pool_args::ThriftHiveMetastore_alter_wm_pool_args() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_wm_pool_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_wm_pool_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_wm_pool_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_wm_pool_pargs::~ThriftHiveMetastore_alter_wm_pool_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_wm_pool_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_wm_pool_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_wm_pool_result::~ThriftHiveMetastore_alter_wm_pool_result() noexcept { +} + +ThriftHiveMetastore_alter_wm_pool_result::ThriftHiveMetastore_alter_wm_pool_result() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_wm_pool_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_wm_pool_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_wm_pool_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_wm_pool_presult::~ThriftHiveMetastore_alter_wm_pool_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_wm_pool_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_wm_pool_args::~ThriftHiveMetastore_drop_wm_pool_args() noexcept { +} + +ThriftHiveMetastore_drop_wm_pool_args::ThriftHiveMetastore_drop_wm_pool_args() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_wm_pool_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_wm_pool_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_wm_pool_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_wm_pool_pargs::~ThriftHiveMetastore_drop_wm_pool_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_wm_pool_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_wm_pool_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_wm_pool_result::~ThriftHiveMetastore_drop_wm_pool_result() noexcept { +} + +ThriftHiveMetastore_drop_wm_pool_result::ThriftHiveMetastore_drop_wm_pool_result() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_wm_pool_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_wm_pool_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_wm_pool_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_wm_pool_presult::~ThriftHiveMetastore_drop_wm_pool_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_wm_pool_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_create_or_update_wm_mapping_args::~ThriftHiveMetastore_create_or_update_wm_mapping_args() noexcept { +} + +ThriftHiveMetastore_create_or_update_wm_mapping_args::ThriftHiveMetastore_create_or_update_wm_mapping_args() noexcept { +} + +uint32_t ThriftHiveMetastore_create_or_update_wm_mapping_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_or_update_wm_mapping_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_or_update_wm_mapping_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_or_update_wm_mapping_pargs::~ThriftHiveMetastore_create_or_update_wm_mapping_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_or_update_wm_mapping_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_or_update_wm_mapping_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_or_update_wm_mapping_result::~ThriftHiveMetastore_create_or_update_wm_mapping_result() noexcept { +} + +ThriftHiveMetastore_create_or_update_wm_mapping_result::ThriftHiveMetastore_create_or_update_wm_mapping_result() noexcept { +} + +uint32_t ThriftHiveMetastore_create_or_update_wm_mapping_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_or_update_wm_mapping_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_or_update_wm_mapping_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_or_update_wm_mapping_presult::~ThriftHiveMetastore_create_or_update_wm_mapping_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_or_update_wm_mapping_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_wm_mapping_args::~ThriftHiveMetastore_drop_wm_mapping_args() noexcept { +} + +ThriftHiveMetastore_drop_wm_mapping_args::ThriftHiveMetastore_drop_wm_mapping_args() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_wm_mapping_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_wm_mapping_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_wm_mapping_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_wm_mapping_pargs::~ThriftHiveMetastore_drop_wm_mapping_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_wm_mapping_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_wm_mapping_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_wm_mapping_result::~ThriftHiveMetastore_drop_wm_mapping_result() noexcept { +} + +ThriftHiveMetastore_drop_wm_mapping_result::ThriftHiveMetastore_drop_wm_mapping_result() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_wm_mapping_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_wm_mapping_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_wm_mapping_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_wm_mapping_presult::~ThriftHiveMetastore_drop_wm_mapping_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_wm_mapping_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args::~ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args() noexcept { +} + +ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args::ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args() noexcept { +} + +uint32_t ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_pargs::~ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result::~ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result() noexcept { +} + +ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result::ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result() noexcept { +} + +uint32_t ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_presult::~ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_create_ischema_args::~ThriftHiveMetastore_create_ischema_args() noexcept { +} + +ThriftHiveMetastore_create_ischema_args::ThriftHiveMetastore_create_ischema_args() noexcept { +} + +uint32_t ThriftHiveMetastore_create_ischema_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->schema.read(iprot); + this->__isset.schema = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_ischema_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_ischema_args"); + + xfer += oprot->writeFieldBegin("schema", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->schema.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_ischema_pargs::~ThriftHiveMetastore_create_ischema_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_ischema_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_ischema_pargs"); + + xfer += oprot->writeFieldBegin("schema", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->schema)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_ischema_result::~ThriftHiveMetastore_create_ischema_result() noexcept { +} + +ThriftHiveMetastore_create_ischema_result::ThriftHiveMetastore_create_ischema_result() noexcept { +} + +uint32_t ThriftHiveMetastore_create_ischema_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_ischema_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_ischema_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_ischema_presult::~ThriftHiveMetastore_create_ischema_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_ischema_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_alter_ischema_args::~ThriftHiveMetastore_alter_ischema_args() noexcept { +} + +ThriftHiveMetastore_alter_ischema_args::ThriftHiveMetastore_alter_ischema_args() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_ischema_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_ischema_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_ischema_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_ischema_pargs::~ThriftHiveMetastore_alter_ischema_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_ischema_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_ischema_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_ischema_result::~ThriftHiveMetastore_alter_ischema_result() noexcept { +} + +ThriftHiveMetastore_alter_ischema_result::ThriftHiveMetastore_alter_ischema_result() noexcept { +} + +uint32_t ThriftHiveMetastore_alter_ischema_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_ischema_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_ischema_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_ischema_presult::~ThriftHiveMetastore_alter_ischema_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_alter_ischema_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_ischema_args::~ThriftHiveMetastore_get_ischema_args() noexcept { +} + +ThriftHiveMetastore_get_ischema_args::ThriftHiveMetastore_get_ischema_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_ischema_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->name.read(iprot); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_ischema_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_ischema_args"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->name.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_ischema_pargs::~ThriftHiveMetastore_get_ischema_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_ischema_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_ischema_pargs"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->name)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_ischema_result::~ThriftHiveMetastore_get_ischema_result() noexcept { +} + +ThriftHiveMetastore_get_ischema_result::ThriftHiveMetastore_get_ischema_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_ischema_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_ischema_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_ischema_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_ischema_presult::~ThriftHiveMetastore_get_ischema_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_ischema_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_ischema_args::~ThriftHiveMetastore_drop_ischema_args() noexcept { +} + +ThriftHiveMetastore_drop_ischema_args::ThriftHiveMetastore_drop_ischema_args() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_ischema_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->name.read(iprot); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_ischema_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_ischema_args"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->name.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_ischema_pargs::~ThriftHiveMetastore_drop_ischema_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_ischema_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_ischema_pargs"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->name)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_ischema_result::~ThriftHiveMetastore_drop_ischema_result() noexcept { +} + +ThriftHiveMetastore_drop_ischema_result::ThriftHiveMetastore_drop_ischema_result() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_ischema_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_ischema_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_ischema_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_ischema_presult::~ThriftHiveMetastore_drop_ischema_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_ischema_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_schema_version_args::~ThriftHiveMetastore_add_schema_version_args() noexcept { +} + +ThriftHiveMetastore_add_schema_version_args::ThriftHiveMetastore_add_schema_version_args() noexcept { +} + +uint32_t ThriftHiveMetastore_add_schema_version_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->schemaVersion.read(iprot); + this->__isset.schemaVersion = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_schema_version_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_schema_version_args"); + + xfer += oprot->writeFieldBegin("schemaVersion", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->schemaVersion.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_schema_version_pargs::~ThriftHiveMetastore_add_schema_version_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_schema_version_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_schema_version_pargs"); + + xfer += oprot->writeFieldBegin("schemaVersion", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->schemaVersion)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_schema_version_result::~ThriftHiveMetastore_add_schema_version_result() noexcept { +} + +ThriftHiveMetastore_add_schema_version_result::ThriftHiveMetastore_add_schema_version_result() noexcept { +} + +uint32_t ThriftHiveMetastore_add_schema_version_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_schema_version_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_schema_version_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_schema_version_presult::~ThriftHiveMetastore_add_schema_version_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_schema_version_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_schema_version_args::~ThriftHiveMetastore_get_schema_version_args() noexcept { +} + +ThriftHiveMetastore_get_schema_version_args::ThriftHiveMetastore_get_schema_version_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_schema_version_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->schemaVersion.read(iprot); + this->__isset.schemaVersion = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_schema_version_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_schema_version_args"); + + xfer += oprot->writeFieldBegin("schemaVersion", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->schemaVersion.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_schema_version_pargs::~ThriftHiveMetastore_get_schema_version_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_schema_version_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_schema_version_pargs"); + + xfer += oprot->writeFieldBegin("schemaVersion", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->schemaVersion)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_schema_version_result::~ThriftHiveMetastore_get_schema_version_result() noexcept { +} + +ThriftHiveMetastore_get_schema_version_result::ThriftHiveMetastore_get_schema_version_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_schema_version_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_schema_version_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_schema_version_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_schema_version_presult::~ThriftHiveMetastore_get_schema_version_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_schema_version_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_schema_latest_version_args::~ThriftHiveMetastore_get_schema_latest_version_args() noexcept { +} + +ThriftHiveMetastore_get_schema_latest_version_args::ThriftHiveMetastore_get_schema_latest_version_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_schema_latest_version_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->schemaName.read(iprot); + this->__isset.schemaName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_schema_latest_version_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_schema_latest_version_args"); + + xfer += oprot->writeFieldBegin("schemaName", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->schemaName.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_schema_latest_version_pargs::~ThriftHiveMetastore_get_schema_latest_version_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_schema_latest_version_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_schema_latest_version_pargs"); + + xfer += oprot->writeFieldBegin("schemaName", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->schemaName)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_schema_latest_version_result::~ThriftHiveMetastore_get_schema_latest_version_result() noexcept { +} + +ThriftHiveMetastore_get_schema_latest_version_result::ThriftHiveMetastore_get_schema_latest_version_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_schema_latest_version_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_schema_latest_version_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_schema_latest_version_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_schema_latest_version_presult::~ThriftHiveMetastore_get_schema_latest_version_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_schema_latest_version_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_schema_all_versions_args::~ThriftHiveMetastore_get_schema_all_versions_args() noexcept { +} + +ThriftHiveMetastore_get_schema_all_versions_args::ThriftHiveMetastore_get_schema_all_versions_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_schema_all_versions_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->schemaName.read(iprot); + this->__isset.schemaName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_schema_all_versions_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_schema_all_versions_args"); + + xfer += oprot->writeFieldBegin("schemaName", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->schemaName.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_schema_all_versions_pargs::~ThriftHiveMetastore_get_schema_all_versions_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_schema_all_versions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_schema_all_versions_pargs"); + + xfer += oprot->writeFieldBegin("schemaName", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->schemaName)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_schema_all_versions_result::~ThriftHiveMetastore_get_schema_all_versions_result() noexcept { +} + +ThriftHiveMetastore_get_schema_all_versions_result::ThriftHiveMetastore_get_schema_all_versions_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_schema_all_versions_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2590; + ::apache::thrift::protocol::TType _etype2593; + xfer += iprot->readListBegin(_etype2593, _size2590); + this->success.resize(_size2590); + uint32_t _i2594; + for (_i2594 = 0; _i2594 < _size2590; ++_i2594) + { + xfer += this->success[_i2594].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_schema_all_versions_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_schema_all_versions_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter2595; + for (_iter2595 = this->success.begin(); _iter2595 != this->success.end(); ++_iter2595) + { + xfer += (*_iter2595).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_schema_all_versions_presult::~ThriftHiveMetastore_get_schema_all_versions_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_schema_all_versions_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2596; + ::apache::thrift::protocol::TType _etype2599; + xfer += iprot->readListBegin(_etype2599, _size2596); + (*(this->success)).resize(_size2596); + uint32_t _i2600; + for (_i2600 = 0; _i2600 < _size2596; ++_i2600) + { + xfer += (*(this->success))[_i2600].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_schema_version_args::~ThriftHiveMetastore_drop_schema_version_args() noexcept { +} + +ThriftHiveMetastore_drop_schema_version_args::ThriftHiveMetastore_drop_schema_version_args() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_schema_version_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->schemaVersion.read(iprot); + this->__isset.schemaVersion = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_schema_version_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_schema_version_args"); + + xfer += oprot->writeFieldBegin("schemaVersion", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->schemaVersion.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_schema_version_pargs::~ThriftHiveMetastore_drop_schema_version_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_schema_version_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_schema_version_pargs"); + + xfer += oprot->writeFieldBegin("schemaVersion", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->schemaVersion)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_schema_version_result::~ThriftHiveMetastore_drop_schema_version_result() noexcept { +} + +ThriftHiveMetastore_drop_schema_version_result::ThriftHiveMetastore_drop_schema_version_result() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_schema_version_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_schema_version_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_schema_version_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_schema_version_presult::~ThriftHiveMetastore_drop_schema_version_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_schema_version_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_schemas_by_cols_args::~ThriftHiveMetastore_get_schemas_by_cols_args() noexcept { +} + +ThriftHiveMetastore_get_schemas_by_cols_args::ThriftHiveMetastore_get_schemas_by_cols_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_schemas_by_cols_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_schemas_by_cols_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_schemas_by_cols_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_schemas_by_cols_pargs::~ThriftHiveMetastore_get_schemas_by_cols_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_schemas_by_cols_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_schemas_by_cols_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_schemas_by_cols_result::~ThriftHiveMetastore_get_schemas_by_cols_result() noexcept { +} + +ThriftHiveMetastore_get_schemas_by_cols_result::ThriftHiveMetastore_get_schemas_by_cols_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_schemas_by_cols_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_schemas_by_cols_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_schemas_by_cols_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_schemas_by_cols_presult::~ThriftHiveMetastore_get_schemas_by_cols_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_schemas_by_cols_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_map_schema_version_to_serde_args::~ThriftHiveMetastore_map_schema_version_to_serde_args() noexcept { +} + +ThriftHiveMetastore_map_schema_version_to_serde_args::ThriftHiveMetastore_map_schema_version_to_serde_args() noexcept { +} + +uint32_t ThriftHiveMetastore_map_schema_version_to_serde_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_map_schema_version_to_serde_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_map_schema_version_to_serde_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_map_schema_version_to_serde_pargs::~ThriftHiveMetastore_map_schema_version_to_serde_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_map_schema_version_to_serde_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_map_schema_version_to_serde_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_map_schema_version_to_serde_result::~ThriftHiveMetastore_map_schema_version_to_serde_result() noexcept { +} + +ThriftHiveMetastore_map_schema_version_to_serde_result::ThriftHiveMetastore_map_schema_version_to_serde_result() noexcept { +} + +uint32_t ThriftHiveMetastore_map_schema_version_to_serde_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_map_schema_version_to_serde_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_map_schema_version_to_serde_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_map_schema_version_to_serde_presult::~ThriftHiveMetastore_map_schema_version_to_serde_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_map_schema_version_to_serde_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_set_schema_version_state_args::~ThriftHiveMetastore_set_schema_version_state_args() noexcept { +} + +ThriftHiveMetastore_set_schema_version_state_args::ThriftHiveMetastore_set_schema_version_state_args() noexcept { +} + +uint32_t ThriftHiveMetastore_set_schema_version_state_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_set_schema_version_state_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_set_schema_version_state_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_set_schema_version_state_pargs::~ThriftHiveMetastore_set_schema_version_state_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_set_schema_version_state_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_set_schema_version_state_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_set_schema_version_state_result::~ThriftHiveMetastore_set_schema_version_state_result() noexcept { +} + +ThriftHiveMetastore_set_schema_version_state_result::ThriftHiveMetastore_set_schema_version_state_result() noexcept { +} + +uint32_t ThriftHiveMetastore_set_schema_version_state_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_set_schema_version_state_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_set_schema_version_state_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_set_schema_version_state_presult::~ThriftHiveMetastore_set_schema_version_state_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_set_schema_version_state_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_serde_args::~ThriftHiveMetastore_add_serde_args() noexcept { +} + +ThriftHiveMetastore_add_serde_args::ThriftHiveMetastore_add_serde_args() noexcept { +} + +uint32_t ThriftHiveMetastore_add_serde_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->serde.read(iprot); + this->__isset.serde = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_serde_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_serde_args"); + + xfer += oprot->writeFieldBegin("serde", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->serde.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_serde_pargs::~ThriftHiveMetastore_add_serde_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_serde_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_serde_pargs"); + + xfer += oprot->writeFieldBegin("serde", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->serde)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_serde_result::~ThriftHiveMetastore_add_serde_result() noexcept { +} + +ThriftHiveMetastore_add_serde_result::ThriftHiveMetastore_add_serde_result() noexcept { +} + +uint32_t ThriftHiveMetastore_add_serde_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_serde_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_serde_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_serde_presult::~ThriftHiveMetastore_add_serde_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_serde_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_serde_args::~ThriftHiveMetastore_get_serde_args() noexcept { +} + +ThriftHiveMetastore_get_serde_args::ThriftHiveMetastore_get_serde_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_serde_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_serde_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_serde_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_serde_pargs::~ThriftHiveMetastore_get_serde_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_serde_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_serde_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_serde_result::~ThriftHiveMetastore_get_serde_result() noexcept { +} + +ThriftHiveMetastore_get_serde_result::ThriftHiveMetastore_get_serde_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_serde_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_serde_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_serde_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_serde_presult::~ThriftHiveMetastore_get_serde_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_serde_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_lock_materialization_rebuild_args::~ThriftHiveMetastore_get_lock_materialization_rebuild_args() noexcept { +} + +ThriftHiveMetastore_get_lock_materialization_rebuild_args::ThriftHiveMetastore_get_lock_materialization_rebuild_args() noexcept + : dbName(), + tableName(), + txnId(0) { +} + +uint32_t ThriftHiveMetastore_get_lock_materialization_rebuild_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + this->__isset.tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnId); + this->__isset.txnId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_lock_materialization_rebuild_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_lock_materialization_rebuild_args"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->txnId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_lock_materialization_rebuild_pargs::~ThriftHiveMetastore_get_lock_materialization_rebuild_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_lock_materialization_rebuild_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_lock_materialization_rebuild_pargs"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->dbName))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tableName))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64((*(this->txnId))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_lock_materialization_rebuild_result::~ThriftHiveMetastore_get_lock_materialization_rebuild_result() noexcept { +} + +ThriftHiveMetastore_get_lock_materialization_rebuild_result::ThriftHiveMetastore_get_lock_materialization_rebuild_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_lock_materialization_rebuild_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_lock_materialization_rebuild_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_lock_materialization_rebuild_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_lock_materialization_rebuild_presult::~ThriftHiveMetastore_get_lock_materialization_rebuild_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_lock_materialization_rebuild_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args::~ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args() noexcept { +} + +ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args::ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args() noexcept + : dbName(), + tableName(), + txnId(0) { +} + +uint32_t ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + this->__isset.tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnId); + this->__isset.txnId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->txnId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_pargs::~ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_pargs"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->dbName))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tableName))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64((*(this->txnId))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result::~ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result() noexcept { +} + +ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result::ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result() noexcept + : success(0) { +} + +uint32_t ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult::~ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_runtime_stats_args::~ThriftHiveMetastore_add_runtime_stats_args() noexcept { +} + +ThriftHiveMetastore_add_runtime_stats_args::ThriftHiveMetastore_add_runtime_stats_args() noexcept { +} + +uint32_t ThriftHiveMetastore_add_runtime_stats_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->stat.read(iprot); + this->__isset.stat = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_runtime_stats_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_runtime_stats_args"); + + xfer += oprot->writeFieldBegin("stat", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->stat.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_runtime_stats_pargs::~ThriftHiveMetastore_add_runtime_stats_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_runtime_stats_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_runtime_stats_pargs"); + + xfer += oprot->writeFieldBegin("stat", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->stat)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_runtime_stats_result::~ThriftHiveMetastore_add_runtime_stats_result() noexcept { +} + +ThriftHiveMetastore_add_runtime_stats_result::ThriftHiveMetastore_add_runtime_stats_result() noexcept { +} + +uint32_t ThriftHiveMetastore_add_runtime_stats_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_runtime_stats_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_runtime_stats_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_runtime_stats_presult::~ThriftHiveMetastore_add_runtime_stats_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_runtime_stats_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_runtime_stats_args::~ThriftHiveMetastore_get_runtime_stats_args() noexcept { +} + +ThriftHiveMetastore_get_runtime_stats_args::ThriftHiveMetastore_get_runtime_stats_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_runtime_stats_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_runtime_stats_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_runtime_stats_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_runtime_stats_pargs::~ThriftHiveMetastore_get_runtime_stats_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_runtime_stats_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_runtime_stats_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_runtime_stats_result::~ThriftHiveMetastore_get_runtime_stats_result() noexcept { +} + +ThriftHiveMetastore_get_runtime_stats_result::ThriftHiveMetastore_get_runtime_stats_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_runtime_stats_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2601; + ::apache::thrift::protocol::TType _etype2604; + xfer += iprot->readListBegin(_etype2604, _size2601); + this->success.resize(_size2601); + uint32_t _i2605; + for (_i2605 = 0; _i2605 < _size2601; ++_i2605) + { + xfer += this->success[_i2605].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_runtime_stats_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_runtime_stats_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter2606; + for (_iter2606 = this->success.begin(); _iter2606 != this->success.end(); ++_iter2606) + { + xfer += (*_iter2606).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_runtime_stats_presult::~ThriftHiveMetastore_get_runtime_stats_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_runtime_stats_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2607; + ::apache::thrift::protocol::TType _etype2610; + xfer += iprot->readListBegin(_etype2610, _size2607); + (*(this->success)).resize(_size2607); + uint32_t _i2611; + for (_i2611 = 0; _i2611 < _size2607; ++_i2611) + { + xfer += (*(this->success))[_i2611].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_partitions_with_specs_args::~ThriftHiveMetastore_get_partitions_with_specs_args() noexcept { +} + +ThriftHiveMetastore_get_partitions_with_specs_args::ThriftHiveMetastore_get_partitions_with_specs_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partitions_with_specs_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_with_specs_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_with_specs_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_with_specs_pargs::~ThriftHiveMetastore_get_partitions_with_specs_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_with_specs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_with_specs_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_with_specs_result::~ThriftHiveMetastore_get_partitions_with_specs_result() noexcept { +} + +ThriftHiveMetastore_get_partitions_with_specs_result::ThriftHiveMetastore_get_partitions_with_specs_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_partitions_with_specs_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_with_specs_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_with_specs_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_partitions_with_specs_presult::~ThriftHiveMetastore_get_partitions_with_specs_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_partitions_with_specs_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_scheduled_query_poll_args::~ThriftHiveMetastore_scheduled_query_poll_args() noexcept { +} + +ThriftHiveMetastore_scheduled_query_poll_args::ThriftHiveMetastore_scheduled_query_poll_args() noexcept { +} + +uint32_t ThriftHiveMetastore_scheduled_query_poll_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_scheduled_query_poll_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_scheduled_query_poll_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_scheduled_query_poll_pargs::~ThriftHiveMetastore_scheduled_query_poll_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_scheduled_query_poll_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_scheduled_query_poll_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_scheduled_query_poll_result::~ThriftHiveMetastore_scheduled_query_poll_result() noexcept { +} + +ThriftHiveMetastore_scheduled_query_poll_result::ThriftHiveMetastore_scheduled_query_poll_result() noexcept { +} + +uint32_t ThriftHiveMetastore_scheduled_query_poll_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_scheduled_query_poll_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_scheduled_query_poll_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_scheduled_query_poll_presult::~ThriftHiveMetastore_scheduled_query_poll_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_scheduled_query_poll_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_scheduled_query_maintenance_args::~ThriftHiveMetastore_scheduled_query_maintenance_args() noexcept { +} + +ThriftHiveMetastore_scheduled_query_maintenance_args::ThriftHiveMetastore_scheduled_query_maintenance_args() noexcept { +} + +uint32_t ThriftHiveMetastore_scheduled_query_maintenance_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_scheduled_query_maintenance_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_scheduled_query_maintenance_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_scheduled_query_maintenance_pargs::~ThriftHiveMetastore_scheduled_query_maintenance_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_scheduled_query_maintenance_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_scheduled_query_maintenance_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_scheduled_query_maintenance_result::~ThriftHiveMetastore_scheduled_query_maintenance_result() noexcept { +} + +ThriftHiveMetastore_scheduled_query_maintenance_result::ThriftHiveMetastore_scheduled_query_maintenance_result() noexcept { +} + +uint32_t ThriftHiveMetastore_scheduled_query_maintenance_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_scheduled_query_maintenance_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_scheduled_query_maintenance_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_scheduled_query_maintenance_presult::~ThriftHiveMetastore_scheduled_query_maintenance_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_scheduled_query_maintenance_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_scheduled_query_progress_args::~ThriftHiveMetastore_scheduled_query_progress_args() noexcept { +} + +ThriftHiveMetastore_scheduled_query_progress_args::ThriftHiveMetastore_scheduled_query_progress_args() noexcept { +} + +uint32_t ThriftHiveMetastore_scheduled_query_progress_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->info.read(iprot); + this->__isset.info = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_scheduled_query_progress_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_scheduled_query_progress_args"); + + xfer += oprot->writeFieldBegin("info", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->info.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_scheduled_query_progress_pargs::~ThriftHiveMetastore_scheduled_query_progress_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_scheduled_query_progress_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_scheduled_query_progress_pargs"); + + xfer += oprot->writeFieldBegin("info", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->info)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_scheduled_query_progress_result::~ThriftHiveMetastore_scheduled_query_progress_result() noexcept { +} + +ThriftHiveMetastore_scheduled_query_progress_result::ThriftHiveMetastore_scheduled_query_progress_result() noexcept { +} + +uint32_t ThriftHiveMetastore_scheduled_query_progress_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_scheduled_query_progress_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_scheduled_query_progress_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_scheduled_query_progress_presult::~ThriftHiveMetastore_scheduled_query_progress_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_scheduled_query_progress_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_scheduled_query_args::~ThriftHiveMetastore_get_scheduled_query_args() noexcept { +} + +ThriftHiveMetastore_get_scheduled_query_args::ThriftHiveMetastore_get_scheduled_query_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_scheduled_query_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->scheduleKey.read(iprot); + this->__isset.scheduleKey = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_scheduled_query_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_scheduled_query_args"); + + xfer += oprot->writeFieldBegin("scheduleKey", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->scheduleKey.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_scheduled_query_pargs::~ThriftHiveMetastore_get_scheduled_query_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_scheduled_query_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_scheduled_query_pargs"); + + xfer += oprot->writeFieldBegin("scheduleKey", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->scheduleKey)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_scheduled_query_result::~ThriftHiveMetastore_get_scheduled_query_result() noexcept { +} + +ThriftHiveMetastore_get_scheduled_query_result::ThriftHiveMetastore_get_scheduled_query_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_scheduled_query_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_scheduled_query_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_scheduled_query_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_scheduled_query_presult::~ThriftHiveMetastore_get_scheduled_query_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_scheduled_query_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_replication_metrics_args::~ThriftHiveMetastore_add_replication_metrics_args() noexcept { +} + +ThriftHiveMetastore_add_replication_metrics_args::ThriftHiveMetastore_add_replication_metrics_args() noexcept { +} + +uint32_t ThriftHiveMetastore_add_replication_metrics_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->replicationMetricList.read(iprot); + this->__isset.replicationMetricList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_replication_metrics_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_replication_metrics_args"); + + xfer += oprot->writeFieldBegin("replicationMetricList", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->replicationMetricList.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_replication_metrics_pargs::~ThriftHiveMetastore_add_replication_metrics_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_replication_metrics_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_replication_metrics_pargs"); + + xfer += oprot->writeFieldBegin("replicationMetricList", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->replicationMetricList)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_replication_metrics_result::~ThriftHiveMetastore_add_replication_metrics_result() noexcept { +} + +ThriftHiveMetastore_add_replication_metrics_result::ThriftHiveMetastore_add_replication_metrics_result() noexcept { +} + +uint32_t ThriftHiveMetastore_add_replication_metrics_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_replication_metrics_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_replication_metrics_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_replication_metrics_presult::~ThriftHiveMetastore_add_replication_metrics_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_replication_metrics_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_replication_metrics_args::~ThriftHiveMetastore_get_replication_metrics_args() noexcept { +} + +ThriftHiveMetastore_get_replication_metrics_args::ThriftHiveMetastore_get_replication_metrics_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_replication_metrics_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_replication_metrics_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_replication_metrics_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_replication_metrics_pargs::~ThriftHiveMetastore_get_replication_metrics_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_replication_metrics_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_replication_metrics_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_replication_metrics_result::~ThriftHiveMetastore_get_replication_metrics_result() noexcept { +} + +ThriftHiveMetastore_get_replication_metrics_result::ThriftHiveMetastore_get_replication_metrics_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_replication_metrics_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_replication_metrics_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_replication_metrics_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_replication_metrics_presult::~ThriftHiveMetastore_get_replication_metrics_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_replication_metrics_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_open_txns_req_args::~ThriftHiveMetastore_get_open_txns_req_args() noexcept { +} + +ThriftHiveMetastore_get_open_txns_req_args::ThriftHiveMetastore_get_open_txns_req_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_open_txns_req_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->getOpenTxnsRequest.read(iprot); + this->__isset.getOpenTxnsRequest = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_open_txns_req_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_req_args"); + + xfer += oprot->writeFieldBegin("getOpenTxnsRequest", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->getOpenTxnsRequest.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_open_txns_req_pargs::~ThriftHiveMetastore_get_open_txns_req_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_open_txns_req_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_req_pargs"); + + xfer += oprot->writeFieldBegin("getOpenTxnsRequest", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->getOpenTxnsRequest)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_open_txns_req_result::~ThriftHiveMetastore_get_open_txns_req_result() noexcept { +} + +ThriftHiveMetastore_get_open_txns_req_result::ThriftHiveMetastore_get_open_txns_req_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_open_txns_req_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_open_txns_req_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_req_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_open_txns_req_presult::~ThriftHiveMetastore_get_open_txns_req_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_open_txns_req_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_create_stored_procedure_args::~ThriftHiveMetastore_create_stored_procedure_args() noexcept { +} + +ThriftHiveMetastore_create_stored_procedure_args::ThriftHiveMetastore_create_stored_procedure_args() noexcept { +} + +uint32_t ThriftHiveMetastore_create_stored_procedure_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->proc.read(iprot); + this->__isset.proc = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_stored_procedure_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_stored_procedure_args"); + + xfer += oprot->writeFieldBegin("proc", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->proc.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_stored_procedure_pargs::~ThriftHiveMetastore_create_stored_procedure_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_stored_procedure_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_stored_procedure_pargs"); + + xfer += oprot->writeFieldBegin("proc", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->proc)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_stored_procedure_result::~ThriftHiveMetastore_create_stored_procedure_result() noexcept { +} + +ThriftHiveMetastore_create_stored_procedure_result::ThriftHiveMetastore_create_stored_procedure_result() noexcept { +} + +uint32_t ThriftHiveMetastore_create_stored_procedure_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_stored_procedure_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_stored_procedure_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_stored_procedure_presult::~ThriftHiveMetastore_create_stored_procedure_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_create_stored_procedure_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_stored_procedure_args::~ThriftHiveMetastore_get_stored_procedure_args() noexcept { +} + +ThriftHiveMetastore_get_stored_procedure_args::ThriftHiveMetastore_get_stored_procedure_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_stored_procedure_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_stored_procedure_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_stored_procedure_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_stored_procedure_pargs::~ThriftHiveMetastore_get_stored_procedure_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_stored_procedure_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_stored_procedure_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_stored_procedure_result::~ThriftHiveMetastore_get_stored_procedure_result() noexcept { +} + +ThriftHiveMetastore_get_stored_procedure_result::ThriftHiveMetastore_get_stored_procedure_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_stored_procedure_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_stored_procedure_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_stored_procedure_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_stored_procedure_presult::~ThriftHiveMetastore_get_stored_procedure_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_stored_procedure_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_stored_procedure_args::~ThriftHiveMetastore_drop_stored_procedure_args() noexcept { +} + +ThriftHiveMetastore_drop_stored_procedure_args::ThriftHiveMetastore_drop_stored_procedure_args() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_stored_procedure_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_stored_procedure_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_stored_procedure_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_stored_procedure_pargs::~ThriftHiveMetastore_drop_stored_procedure_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_stored_procedure_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_stored_procedure_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_stored_procedure_result::~ThriftHiveMetastore_drop_stored_procedure_result() noexcept { +} + +ThriftHiveMetastore_drop_stored_procedure_result::ThriftHiveMetastore_drop_stored_procedure_result() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_stored_procedure_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_stored_procedure_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_stored_procedure_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_stored_procedure_presult::~ThriftHiveMetastore_drop_stored_procedure_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_stored_procedure_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_all_stored_procedures_args::~ThriftHiveMetastore_get_all_stored_procedures_args() noexcept { +} + +ThriftHiveMetastore_get_all_stored_procedures_args::ThriftHiveMetastore_get_all_stored_procedures_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_all_stored_procedures_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_all_stored_procedures_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_stored_procedures_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_stored_procedures_pargs::~ThriftHiveMetastore_get_all_stored_procedures_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_all_stored_procedures_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_stored_procedures_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_stored_procedures_result::~ThriftHiveMetastore_get_all_stored_procedures_result() noexcept { +} + +ThriftHiveMetastore_get_all_stored_procedures_result::ThriftHiveMetastore_get_all_stored_procedures_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_all_stored_procedures_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2612; + ::apache::thrift::protocol::TType _etype2615; + xfer += iprot->readListBegin(_etype2615, _size2612); + this->success.resize(_size2612); + uint32_t _i2616; + for (_i2616 = 0; _i2616 < _size2612; ++_i2616) + { + xfer += iprot->readString(this->success[_i2616]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_all_stored_procedures_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_stored_procedures_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::vector ::const_iterator _iter2617; + for (_iter2617 = this->success.begin(); _iter2617 != this->success.end(); ++_iter2617) + { + xfer += oprot->writeString((*_iter2617)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_stored_procedures_presult::~ThriftHiveMetastore_get_all_stored_procedures_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_all_stored_procedures_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2618; + ::apache::thrift::protocol::TType _etype2621; + xfer += iprot->readListBegin(_etype2621, _size2618); + (*(this->success)).resize(_size2618); + uint32_t _i2622; + for (_i2622 = 0; _i2622 < _size2618; ++_i2622) + { + xfer += iprot->readString((*(this->success))[_i2622]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_find_package_args::~ThriftHiveMetastore_find_package_args() noexcept { +} + +ThriftHiveMetastore_find_package_args::ThriftHiveMetastore_find_package_args() noexcept { +} + +uint32_t ThriftHiveMetastore_find_package_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_find_package_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_find_package_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_find_package_pargs::~ThriftHiveMetastore_find_package_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_find_package_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_find_package_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_find_package_result::~ThriftHiveMetastore_find_package_result() noexcept { +} + +ThriftHiveMetastore_find_package_result::ThriftHiveMetastore_find_package_result() noexcept { +} + +uint32_t ThriftHiveMetastore_find_package_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_find_package_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_find_package_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_find_package_presult::~ThriftHiveMetastore_find_package_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_find_package_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_package_args::~ThriftHiveMetastore_add_package_args() noexcept { +} + +ThriftHiveMetastore_add_package_args::ThriftHiveMetastore_add_package_args() noexcept { +} + +uint32_t ThriftHiveMetastore_add_package_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_package_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_package_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_package_pargs::~ThriftHiveMetastore_add_package_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_package_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_package_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_package_result::~ThriftHiveMetastore_add_package_result() noexcept { +} + +ThriftHiveMetastore_add_package_result::ThriftHiveMetastore_add_package_result() noexcept { +} + +uint32_t ThriftHiveMetastore_add_package_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_package_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_package_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_package_presult::~ThriftHiveMetastore_add_package_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_package_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_all_packages_args::~ThriftHiveMetastore_get_all_packages_args() noexcept { +} + +ThriftHiveMetastore_get_all_packages_args::ThriftHiveMetastore_get_all_packages_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_all_packages_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_all_packages_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_packages_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_packages_pargs::~ThriftHiveMetastore_get_all_packages_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_all_packages_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_packages_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_packages_result::~ThriftHiveMetastore_get_all_packages_result() noexcept { +} + +ThriftHiveMetastore_get_all_packages_result::ThriftHiveMetastore_get_all_packages_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_all_packages_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2623; + ::apache::thrift::protocol::TType _etype2626; + xfer += iprot->readListBegin(_etype2626, _size2623); + this->success.resize(_size2623); + uint32_t _i2627; + for (_i2627 = 0; _i2627 < _size2623; ++_i2627) + { + xfer += iprot->readString(this->success[_i2627]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_all_packages_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_packages_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::vector ::const_iterator _iter2628; + for (_iter2628 = this->success.begin(); _iter2628 != this->success.end(); ++_iter2628) + { + xfer += oprot->writeString((*_iter2628)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_packages_presult::~ThriftHiveMetastore_get_all_packages_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_all_packages_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2629; + ::apache::thrift::protocol::TType _etype2632; + xfer += iprot->readListBegin(_etype2632, _size2629); + (*(this->success)).resize(_size2629); + uint32_t _i2633; + for (_i2633 = 0; _i2633 < _size2629; ++_i2633) + { + xfer += iprot->readString((*(this->success))[_i2633]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_package_args::~ThriftHiveMetastore_drop_package_args() noexcept { +} + +ThriftHiveMetastore_drop_package_args::ThriftHiveMetastore_drop_package_args() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_package_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_package_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_package_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_package_pargs::~ThriftHiveMetastore_drop_package_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_package_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_package_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_package_result::~ThriftHiveMetastore_drop_package_result() noexcept { +} + +ThriftHiveMetastore_drop_package_result::ThriftHiveMetastore_drop_package_result() noexcept { +} + +uint32_t ThriftHiveMetastore_drop_package_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_package_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_package_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_package_presult::~ThriftHiveMetastore_drop_package_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_drop_package_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_all_write_event_info_args::~ThriftHiveMetastore_get_all_write_event_info_args() noexcept { +} + +ThriftHiveMetastore_get_all_write_event_info_args::ThriftHiveMetastore_get_all_write_event_info_args() noexcept { +} + +uint32_t ThriftHiveMetastore_get_all_write_event_info_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_all_write_event_info_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_write_event_info_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_write_event_info_pargs::~ThriftHiveMetastore_get_all_write_event_info_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_all_write_event_info_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_write_event_info_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_write_event_info_result::~ThriftHiveMetastore_get_all_write_event_info_result() noexcept { +} + +ThriftHiveMetastore_get_all_write_event_info_result::ThriftHiveMetastore_get_all_write_event_info_result() noexcept { +} + +uint32_t ThriftHiveMetastore_get_all_write_event_info_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2634; + ::apache::thrift::protocol::TType _etype2637; + xfer += iprot->readListBegin(_etype2637, _size2634); + this->success.resize(_size2634); + uint32_t _i2638; + for (_i2638 = 0; _i2638 < _size2634; ++_i2638) + { + xfer += this->success[_i2638].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_all_write_event_info_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_write_event_info_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter2639; + for (_iter2639 = this->success.begin(); _iter2639 != this->success.end(); ++_iter2639) + { + xfer += (*_iter2639).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_write_event_info_presult::~ThriftHiveMetastore_get_all_write_event_info_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_get_all_write_event_info_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size2640; + ::apache::thrift::protocol::TType _etype2643; + xfer += iprot->readListBegin(_etype2643, _size2640); + (*(this->success)).resize(_size2640); + uint32_t _i2644; + for (_i2644 = 0; _i2644 < _size2640; ++_i2644) + { + xfer += (*(this->success))[_i2644].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +void ThriftHiveMetastoreClient::abort_Compactions(AbortCompactResponse& _return, const AbortCompactionRequest& rqst) +{ + send_abort_Compactions(rqst); + recv_abort_Compactions(_return); +} + +void ThriftHiveMetastoreClient::send_abort_Compactions(const AbortCompactionRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("abort_Compactions", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_abort_Compactions_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_abort_Compactions(AbortCompactResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("abort_Compactions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_abort_Compactions_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "abort_Compactions failed: unknown result"); +} + +void ThriftHiveMetastoreClient::getMetaConf(std::string& _return, const std::string& key) +{ + send_getMetaConf(key); + recv_getMetaConf(_return); +} + +void ThriftHiveMetastoreClient::send_getMetaConf(const std::string& key) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("getMetaConf", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_getMetaConf_pargs args; + args.key = &key; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_getMetaConf(std::string& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getMetaConf") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_getMetaConf_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getMetaConf failed: unknown result"); +} + +void ThriftHiveMetastoreClient::setMetaConf(const std::string& key, const std::string& value) +{ + send_setMetaConf(key, value); + recv_setMetaConf(); +} + +void ThriftHiveMetastoreClient::send_setMetaConf(const std::string& key, const std::string& value) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("setMetaConf", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_setMetaConf_pargs args; + args.key = &key; + args.value = &value; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_setMetaConf() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("setMetaConf") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_setMetaConf_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + return; +} + +void ThriftHiveMetastoreClient::create_catalog(const CreateCatalogRequest& catalog) +{ + send_create_catalog(catalog); + recv_create_catalog(); +} + +void ThriftHiveMetastoreClient::send_create_catalog(const CreateCatalogRequest& catalog) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("create_catalog", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_catalog_pargs args; + args.catalog = &catalog; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_create_catalog() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_catalog") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_create_catalog_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + return; +} + +void ThriftHiveMetastoreClient::alter_catalog(const AlterCatalogRequest& rqst) +{ + send_alter_catalog(rqst); + recv_alter_catalog(); +} + +void ThriftHiveMetastoreClient::send_alter_catalog(const AlterCatalogRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("alter_catalog", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_catalog_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_alter_catalog() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_catalog") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_alter_catalog_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + return; +} + +void ThriftHiveMetastoreClient::get_catalog(GetCatalogResponse& _return, const GetCatalogRequest& catName) +{ + send_get_catalog(catName); + recv_get_catalog(_return); +} + +void ThriftHiveMetastoreClient::send_get_catalog(const GetCatalogRequest& catName) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_catalog", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_catalog_pargs args; + args.catName = &catName; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_catalog(GetCatalogResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_catalog") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_catalog_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_catalog failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_catalogs(GetCatalogsResponse& _return) +{ + send_get_catalogs(); + recv_get_catalogs(_return); +} + +void ThriftHiveMetastoreClient::send_get_catalogs() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_catalogs", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_catalogs_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_catalogs(GetCatalogsResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_catalogs") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_catalogs_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_catalogs failed: unknown result"); +} + +void ThriftHiveMetastoreClient::drop_catalog(const DropCatalogRequest& catName) +{ + send_drop_catalog(catName); + recv_drop_catalog(); +} + +void ThriftHiveMetastoreClient::send_drop_catalog(const DropCatalogRequest& catName) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_catalog", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_catalog_pargs args; + args.catName = &catName; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_drop_catalog() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_catalog") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_drop_catalog_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + return; +} + +void ThriftHiveMetastoreClient::create_database(const Database& database) +{ + send_create_database(database); + recv_create_database(); +} + +void ThriftHiveMetastoreClient::send_create_database(const Database& database) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("create_database", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_database_pargs args; + args.database = &database; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_create_database() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_database") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_create_database_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + return; +} + +void ThriftHiveMetastoreClient::create_database_req(const CreateDatabaseRequest& createDatabaseRequest) +{ + send_create_database_req(createDatabaseRequest); + recv_create_database_req(); +} + +void ThriftHiveMetastoreClient::send_create_database_req(const CreateDatabaseRequest& createDatabaseRequest) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("create_database_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_database_req_pargs args; + args.createDatabaseRequest = &createDatabaseRequest; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_create_database_req() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_database_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_create_database_req_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + return; +} + +void ThriftHiveMetastoreClient::get_database(Database& _return, const std::string& name) +{ + send_get_database(name); + recv_get_database(_return); +} + +void ThriftHiveMetastoreClient::send_get_database(const std::string& name) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_database", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_database_pargs args; + args.name = &name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_database(Database& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_database") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_database_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_database failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_database_req(Database& _return, const GetDatabaseRequest& request) +{ + send_get_database_req(request); + recv_get_database_req(_return); +} + +void ThriftHiveMetastoreClient::send_get_database_req(const GetDatabaseRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_database_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_database_req_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_database_req(Database& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_database_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_database_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_database_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::drop_database(const std::string& name, const bool deleteData, const bool cascade) +{ + send_drop_database(name, deleteData, cascade); + recv_drop_database(); +} + +void ThriftHiveMetastoreClient::send_drop_database(const std::string& name, const bool deleteData, const bool cascade) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_database", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_database_pargs args; + args.name = &name; + args.deleteData = &deleteData; + args.cascade = &cascade; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_drop_database() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_database") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_drop_database_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + return; +} + +void ThriftHiveMetastoreClient::drop_database_req(const DropDatabaseRequest& req) +{ + send_drop_database_req(req); + recv_drop_database_req(); +} + +void ThriftHiveMetastoreClient::send_drop_database_req(const DropDatabaseRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_database_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_database_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_drop_database_req() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_database_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_drop_database_req_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + return; +} + +void ThriftHiveMetastoreClient::get_databases(std::vector & _return, const std::string& pattern) +{ + send_get_databases(pattern); + recv_get_databases(_return); +} + +void ThriftHiveMetastoreClient::send_get_databases(const std::string& pattern) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_databases", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_databases_pargs args; + args.pattern = &pattern; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_databases(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_databases") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_databases_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_databases failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_all_databases(std::vector & _return) +{ + send_get_all_databases(); + recv_get_all_databases(_return); +} + +void ThriftHiveMetastoreClient::send_get_all_databases() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_all_databases", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_all_databases_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_all_databases(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_all_databases") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_all_databases_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_databases failed: unknown result"); +} + +void ThriftHiveMetastoreClient::alter_database(const std::string& dbname, const Database& db) +{ + send_alter_database(dbname, db); + recv_alter_database(); +} + +void ThriftHiveMetastoreClient::send_alter_database(const std::string& dbname, const Database& db) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("alter_database", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_database_pargs args; + args.dbname = &dbname; + args.db = &db; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_alter_database() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_database") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_alter_database_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::alter_database_req(const AlterDatabaseRequest& alterDbReq) +{ + send_alter_database_req(alterDbReq); + recv_alter_database_req(); +} + +void ThriftHiveMetastoreClient::send_alter_database_req(const AlterDatabaseRequest& alterDbReq) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("alter_database_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_database_req_pargs args; + args.alterDbReq = &alterDbReq; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_alter_database_req() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_database_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_alter_database_req_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::create_dataconnector_req(const CreateDataConnectorRequest& connectorReq) +{ + send_create_dataconnector_req(connectorReq); + recv_create_dataconnector_req(); +} + +void ThriftHiveMetastoreClient::send_create_dataconnector_req(const CreateDataConnectorRequest& connectorReq) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("create_dataconnector_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_dataconnector_req_pargs args; + args.connectorReq = &connectorReq; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_create_dataconnector_req() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_dataconnector_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_create_dataconnector_req_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + return; +} + +void ThriftHiveMetastoreClient::get_dataconnector_req(DataConnector& _return, const GetDataConnectorRequest& request) +{ + send_get_dataconnector_req(request); + recv_get_dataconnector_req(_return); +} + +void ThriftHiveMetastoreClient::send_get_dataconnector_req(const GetDataConnectorRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_dataconnector_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_dataconnector_req_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_dataconnector_req(DataConnector& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_dataconnector_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_dataconnector_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_dataconnector_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::drop_dataconnector_req(const DropDataConnectorRequest& dropDcReq) +{ + send_drop_dataconnector_req(dropDcReq); + recv_drop_dataconnector_req(); +} + +void ThriftHiveMetastoreClient::send_drop_dataconnector_req(const DropDataConnectorRequest& dropDcReq) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_dataconnector_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_dataconnector_req_pargs args; + args.dropDcReq = &dropDcReq; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_drop_dataconnector_req() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_dataconnector_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_drop_dataconnector_req_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + return; +} + +void ThriftHiveMetastoreClient::get_dataconnectors(std::vector & _return) +{ + send_get_dataconnectors(); + recv_get_dataconnectors(_return); +} + +void ThriftHiveMetastoreClient::send_get_dataconnectors() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_dataconnectors", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_dataconnectors_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_dataconnectors(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_dataconnectors") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_dataconnectors_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_dataconnectors failed: unknown result"); +} + +void ThriftHiveMetastoreClient::alter_dataconnector_req(const AlterDataConnectorRequest& alterReq) +{ + send_alter_dataconnector_req(alterReq); + recv_alter_dataconnector_req(); +} + +void ThriftHiveMetastoreClient::send_alter_dataconnector_req(const AlterDataConnectorRequest& alterReq) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("alter_dataconnector_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_dataconnector_req_pargs args; + args.alterReq = &alterReq; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_alter_dataconnector_req() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_dataconnector_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_alter_dataconnector_req_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::get_type(Type& _return, const std::string& name) +{ + send_get_type(name); + recv_get_type(_return); +} + +void ThriftHiveMetastoreClient::send_get_type(const std::string& name) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_type", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_type_pargs args; + args.name = &name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_type(Type& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_type") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_type_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_type failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::create_type(const Type& type) +{ + send_create_type(type); + return recv_create_type(); +} + +void ThriftHiveMetastoreClient::send_create_type(const Type& type) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("create_type", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_type_pargs args; + args.type = &type; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_create_type() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_type") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_create_type_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "create_type failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::drop_type(const std::string& type) +{ + send_drop_type(type); + return recv_drop_type(); +} + +void ThriftHiveMetastoreClient::send_drop_type(const std::string& type) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_type", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_type_pargs args; + args.type = &type; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_drop_type() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_type") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_drop_type_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_type failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_type_all(std::map & _return, const std::string& name) +{ + send_get_type_all(name); + recv_get_type_all(_return); +} + +void ThriftHiveMetastoreClient::send_get_type_all(const std::string& name) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_type_all", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_type_all_pargs args; + args.name = &name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_type_all(std::map & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_type_all") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_type_all_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_type_all failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_fields(std::vector & _return, const std::string& db_name, const std::string& table_name) +{ + send_get_fields(db_name, table_name); + recv_get_fields(_return); +} + +void ThriftHiveMetastoreClient::send_get_fields(const std::string& db_name, const std::string& table_name) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_fields", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_fields_pargs args; + args.db_name = &db_name; + args.table_name = &table_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_fields(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_fields") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_fields_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_fields failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_fields_with_environment_context(std::vector & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) +{ + send_get_fields_with_environment_context(db_name, table_name, environment_context); + recv_get_fields_with_environment_context(_return); +} + +void ThriftHiveMetastoreClient::send_get_fields_with_environment_context(const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_fields_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_fields_with_environment_context_pargs args; + args.db_name = &db_name; + args.table_name = &table_name; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_fields_with_environment_context(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_fields_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_fields_with_environment_context_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_fields_with_environment_context failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_fields_req(GetFieldsResponse& _return, const GetFieldsRequest& req) +{ + send_get_fields_req(req); + recv_get_fields_req(_return); +} + +void ThriftHiveMetastoreClient::send_get_fields_req(const GetFieldsRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_fields_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_fields_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_fields_req(GetFieldsResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_fields_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_fields_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_fields_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_schema(std::vector & _return, const std::string& db_name, const std::string& table_name) +{ + send_get_schema(db_name, table_name); + recv_get_schema(_return); +} + +void ThriftHiveMetastoreClient::send_get_schema(const std::string& db_name, const std::string& table_name) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_schema", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_schema_pargs args; + args.db_name = &db_name; + args.table_name = &table_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_schema(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_schema") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_schema_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_schema failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_schema_with_environment_context(std::vector & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) +{ + send_get_schema_with_environment_context(db_name, table_name, environment_context); + recv_get_schema_with_environment_context(_return); +} + +void ThriftHiveMetastoreClient::send_get_schema_with_environment_context(const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_schema_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_schema_with_environment_context_pargs args; + args.db_name = &db_name; + args.table_name = &table_name; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_schema_with_environment_context(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_schema_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_schema_with_environment_context_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_schema_with_environment_context failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_schema_req(GetSchemaResponse& _return, const GetSchemaRequest& req) +{ + send_get_schema_req(req); + recv_get_schema_req(_return); +} + +void ThriftHiveMetastoreClient::send_get_schema_req(const GetSchemaRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_schema_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_schema_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_schema_req(GetSchemaResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_schema_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_schema_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_schema_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::create_table(const Table& tbl) +{ + send_create_table(tbl); + recv_create_table(); +} + +void ThriftHiveMetastoreClient::send_create_table(const Table& tbl) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("create_table", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_table_pargs args; + args.tbl = &tbl; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_create_table() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_table") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_create_table_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + return; +} + +void ThriftHiveMetastoreClient::create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context) +{ + send_create_table_with_environment_context(tbl, environment_context); + recv_create_table_with_environment_context(); +} + +void ThriftHiveMetastoreClient::send_create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("create_table_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_table_with_environment_context_pargs args; + args.tbl = &tbl; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_create_table_with_environment_context() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_table_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_create_table_with_environment_context_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + return; +} + +void ThriftHiveMetastoreClient::create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys, const std::vector & uniqueConstraints, const std::vector & notNullConstraints, const std::vector & defaultConstraints, const std::vector & checkConstraints) +{ + send_create_table_with_constraints(tbl, primaryKeys, foreignKeys, uniqueConstraints, notNullConstraints, defaultConstraints, checkConstraints); + recv_create_table_with_constraints(); +} + +void ThriftHiveMetastoreClient::send_create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys, const std::vector & uniqueConstraints, const std::vector & notNullConstraints, const std::vector & defaultConstraints, const std::vector & checkConstraints) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("create_table_with_constraints", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_table_with_constraints_pargs args; + args.tbl = &tbl; + args.primaryKeys = &primaryKeys; + args.foreignKeys = &foreignKeys; + args.uniqueConstraints = &uniqueConstraints; + args.notNullConstraints = ¬NullConstraints; + args.defaultConstraints = &defaultConstraints; + args.checkConstraints = &checkConstraints; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_create_table_with_constraints() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_table_with_constraints") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_create_table_with_constraints_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + return; +} + +void ThriftHiveMetastoreClient::create_table_req(const CreateTableRequest& request) +{ + send_create_table_req(request); + recv_create_table_req(); +} + +void ThriftHiveMetastoreClient::send_create_table_req(const CreateTableRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("create_table_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_table_req_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_create_table_req() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_table_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_create_table_req_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + return; +} + +void ThriftHiveMetastoreClient::drop_constraint(const DropConstraintRequest& req) +{ + send_drop_constraint(req); + recv_drop_constraint(); +} + +void ThriftHiveMetastoreClient::send_drop_constraint(const DropConstraintRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_constraint", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_constraint_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_drop_constraint() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_constraint") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_drop_constraint_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o3) { + throw result.o3; + } + return; +} + +void ThriftHiveMetastoreClient::add_primary_key(const AddPrimaryKeyRequest& req) +{ + send_add_primary_key(req); + recv_add_primary_key(); +} + +void ThriftHiveMetastoreClient::send_add_primary_key(const AddPrimaryKeyRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("add_primary_key", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_primary_key_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_add_primary_key() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_primary_key") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_add_primary_key_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::add_foreign_key(const AddForeignKeyRequest& req) +{ + send_add_foreign_key(req); + recv_add_foreign_key(); +} + +void ThriftHiveMetastoreClient::send_add_foreign_key(const AddForeignKeyRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("add_foreign_key", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_foreign_key_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_add_foreign_key() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_foreign_key") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_add_foreign_key_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::add_unique_constraint(const AddUniqueConstraintRequest& req) +{ + send_add_unique_constraint(req); + recv_add_unique_constraint(); +} + +void ThriftHiveMetastoreClient::send_add_unique_constraint(const AddUniqueConstraintRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("add_unique_constraint", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_unique_constraint_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_add_unique_constraint() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_unique_constraint") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_add_unique_constraint_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::add_not_null_constraint(const AddNotNullConstraintRequest& req) +{ + send_add_not_null_constraint(req); + recv_add_not_null_constraint(); +} + +void ThriftHiveMetastoreClient::send_add_not_null_constraint(const AddNotNullConstraintRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("add_not_null_constraint", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_not_null_constraint_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_add_not_null_constraint() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_not_null_constraint") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_add_not_null_constraint_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::add_default_constraint(const AddDefaultConstraintRequest& req) +{ + send_add_default_constraint(req); + recv_add_default_constraint(); +} + +void ThriftHiveMetastoreClient::send_add_default_constraint(const AddDefaultConstraintRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("add_default_constraint", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_default_constraint_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_add_default_constraint() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_default_constraint") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_add_default_constraint_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::add_check_constraint(const AddCheckConstraintRequest& req) +{ + send_add_check_constraint(req); + recv_add_check_constraint(); +} + +void ThriftHiveMetastoreClient::send_add_check_constraint(const AddCheckConstraintRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("add_check_constraint", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_check_constraint_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_add_check_constraint() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_check_constraint") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_add_check_constraint_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::translate_table_dryrun(Table& _return, const CreateTableRequest& request) +{ + send_translate_table_dryrun(request); + recv_translate_table_dryrun(_return); +} + +void ThriftHiveMetastoreClient::send_translate_table_dryrun(const CreateTableRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("translate_table_dryrun", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_translate_table_dryrun_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_translate_table_dryrun(Table& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("translate_table_dryrun") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_translate_table_dryrun_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "translate_table_dryrun failed: unknown result"); +} + +void ThriftHiveMetastoreClient::drop_table(const std::string& dbname, const std::string& name, const bool deleteData) +{ + send_drop_table(dbname, name, deleteData); + recv_drop_table(); +} + +void ThriftHiveMetastoreClient::send_drop_table(const std::string& dbname, const std::string& name, const bool deleteData) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_table", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_table_pargs args; + args.dbname = &dbname; + args.name = &name; + args.deleteData = &deleteData; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_drop_table() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_table") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_drop_table_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o3) { + throw result.o3; + } + return; +} + +void ThriftHiveMetastoreClient::drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context) +{ + send_drop_table_with_environment_context(dbname, name, deleteData, environment_context); + recv_drop_table_with_environment_context(); +} + +void ThriftHiveMetastoreClient::send_drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_table_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_table_with_environment_context_pargs args; + args.dbname = &dbname; + args.name = &name; + args.deleteData = &deleteData; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_drop_table_with_environment_context() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_table_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_drop_table_with_environment_context_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o3) { + throw result.o3; + } + return; +} + +void ThriftHiveMetastoreClient::drop_table_req(const DropTableRequest& dropTableReq) +{ + send_drop_table_req(dropTableReq); + recv_drop_table_req(); +} + +void ThriftHiveMetastoreClient::send_drop_table_req(const DropTableRequest& dropTableReq) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_table_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_table_req_pargs args; + args.dropTableReq = &dropTableReq; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_drop_table_req() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_table_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_drop_table_req_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o3) { + throw result.o3; + } + return; +} + +void ThriftHiveMetastoreClient::truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames) +{ + send_truncate_table(dbName, tableName, partNames); + recv_truncate_table(); +} + +void ThriftHiveMetastoreClient::send_truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("truncate_table", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_truncate_table_pargs args; + args.dbName = &dbName; + args.tableName = &tableName; + args.partNames = &partNames; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_truncate_table() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("truncate_table") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_truncate_table_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + return; +} + +void ThriftHiveMetastoreClient::truncate_table_req(TruncateTableResponse& _return, const TruncateTableRequest& req) +{ + send_truncate_table_req(req); + recv_truncate_table_req(_return); +} + +void ThriftHiveMetastoreClient::send_truncate_table_req(const TruncateTableRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("truncate_table_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_truncate_table_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_truncate_table_req(TruncateTableResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("truncate_table_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_truncate_table_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "truncate_table_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_tables(std::vector & _return, const std::string& db_name, const std::string& pattern) +{ + send_get_tables(db_name, pattern); + recv_get_tables(_return); +} + +void ThriftHiveMetastoreClient::send_get_tables(const std::string& db_name, const std::string& pattern) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_tables", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_tables_pargs args; + args.db_name = &db_name; + args.pattern = &pattern; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_tables(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_tables") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_tables_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_tables failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_tables_by_type(std::vector & _return, const std::string& db_name, const std::string& pattern, const std::string& tableType) +{ + send_get_tables_by_type(db_name, pattern, tableType); + recv_get_tables_by_type(_return); +} + +void ThriftHiveMetastoreClient::send_get_tables_by_type(const std::string& db_name, const std::string& pattern, const std::string& tableType) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_tables_by_type", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_tables_by_type_pargs args; + args.db_name = &db_name; + args.pattern = &pattern; + args.tableType = &tableType; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_tables_by_type(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_tables_by_type") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_tables_by_type_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_tables_by_type failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_all_materialized_view_objects_for_rewriting(std::vector
& _return) +{ + send_get_all_materialized_view_objects_for_rewriting(); + recv_get_all_materialized_view_objects_for_rewriting(_return); +} + +void ThriftHiveMetastoreClient::send_get_all_materialized_view_objects_for_rewriting() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_all_materialized_view_objects_for_rewriting", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_all_materialized_view_objects_for_rewriting(std::vector
& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_all_materialized_view_objects_for_rewriting") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_materialized_view_objects_for_rewriting failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_materialized_views_for_rewriting(std::vector & _return, const std::string& db_name) +{ + send_get_materialized_views_for_rewriting(db_name); + recv_get_materialized_views_for_rewriting(_return); +} + +void ThriftHiveMetastoreClient::send_get_materialized_views_for_rewriting(const std::string& db_name) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_materialized_views_for_rewriting", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_materialized_views_for_rewriting_pargs args; + args.db_name = &db_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_materialized_views_for_rewriting(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_materialized_views_for_rewriting") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_materialized_views_for_rewriting_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_materialized_views_for_rewriting failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_table_meta(std::vector & _return, const std::string& db_patterns, const std::string& tbl_patterns, const std::vector & tbl_types) +{ + send_get_table_meta(db_patterns, tbl_patterns, tbl_types); + recv_get_table_meta(_return); +} + +void ThriftHiveMetastoreClient::send_get_table_meta(const std::string& db_patterns, const std::string& tbl_patterns, const std::vector & tbl_types) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_table_meta", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_table_meta_pargs args; + args.db_patterns = &db_patterns; + args.tbl_patterns = &tbl_patterns; + args.tbl_types = &tbl_types; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_table_meta(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_table_meta") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_table_meta_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_table_meta failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_all_tables(std::vector & _return, const std::string& db_name) +{ + send_get_all_tables(db_name); + recv_get_all_tables(_return); +} + +void ThriftHiveMetastoreClient::send_get_all_tables(const std::string& db_name) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_all_tables", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_all_tables_pargs args; + args.db_name = &db_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_all_tables(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_all_tables") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_all_tables_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_tables failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_tables_ext(std::vector & _return, const GetTablesExtRequest& req) +{ + send_get_tables_ext(req); + recv_get_tables_ext(_return); +} + +void ThriftHiveMetastoreClient::send_get_tables_ext(const GetTablesExtRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_tables_ext", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_tables_ext_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_tables_ext(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_tables_ext") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_tables_ext_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_tables_ext failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_table_req(GetTableResult& _return, const GetTableRequest& req) +{ + send_get_table_req(req); + recv_get_table_req(_return); +} + +void ThriftHiveMetastoreClient::send_get_table_req(const GetTableRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_table_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_table_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_table_req(GetTableResult& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_table_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_table_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_table_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_table_objects_by_name_req(GetTablesResult& _return, const GetTablesRequest& req) +{ + send_get_table_objects_by_name_req(req); + recv_get_table_objects_by_name_req(_return); +} + +void ThriftHiveMetastoreClient::send_get_table_objects_by_name_req(const GetTablesRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_table_objects_by_name_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_table_objects_by_name_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_table_objects_by_name_req(GetTablesResult& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_table_objects_by_name_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_table_objects_by_name_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_table_objects_by_name_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_materialization_invalidation_info(Materialization& _return, const CreationMetadata& creation_metadata, const std::string& validTxnList) +{ + send_get_materialization_invalidation_info(creation_metadata, validTxnList); + recv_get_materialization_invalidation_info(_return); +} + +void ThriftHiveMetastoreClient::send_get_materialization_invalidation_info(const CreationMetadata& creation_metadata, const std::string& validTxnList) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_materialization_invalidation_info", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_materialization_invalidation_info_pargs args; + args.creation_metadata = &creation_metadata; + args.validTxnList = &validTxnList; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_materialization_invalidation_info(Materialization& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_materialization_invalidation_info") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_materialization_invalidation_info_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_materialization_invalidation_info failed: unknown result"); +} + +void ThriftHiveMetastoreClient::update_creation_metadata(const std::string& catName, const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata) +{ + send_update_creation_metadata(catName, dbname, tbl_name, creation_metadata); + recv_update_creation_metadata(); +} + +void ThriftHiveMetastoreClient::send_update_creation_metadata(const std::string& catName, const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("update_creation_metadata", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_update_creation_metadata_pargs args; + args.catName = &catName; + args.dbname = &dbname; + args.tbl_name = &tbl_name; + args.creation_metadata = &creation_metadata; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_update_creation_metadata() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("update_creation_metadata") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_update_creation_metadata_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + return; +} + +void ThriftHiveMetastoreClient::get_table_names_by_filter(std::vector & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables) +{ + send_get_table_names_by_filter(dbname, filter, max_tables); + recv_get_table_names_by_filter(_return); +} + +void ThriftHiveMetastoreClient::send_get_table_names_by_filter(const std::string& dbname, const std::string& filter, const int16_t max_tables) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_table_names_by_filter", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_table_names_by_filter_pargs args; + args.dbname = &dbname; + args.filter = &filter; + args.max_tables = &max_tables; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_table_names_by_filter(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_table_names_by_filter") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_table_names_by_filter_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_table_names_by_filter failed: unknown result"); +} + +void ThriftHiveMetastoreClient::alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl) +{ + send_alter_table(dbname, tbl_name, new_tbl); + recv_alter_table(); +} + +void ThriftHiveMetastoreClient::send_alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("alter_table", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_table_pargs args; + args.dbname = &dbname; + args.tbl_name = &tbl_name; + args.new_tbl = &new_tbl; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_alter_table() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_table") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_alter_table_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context) +{ + send_alter_table_with_environment_context(dbname, tbl_name, new_tbl, environment_context); + recv_alter_table_with_environment_context(); +} + +void ThriftHiveMetastoreClient::send_alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("alter_table_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_table_with_environment_context_pargs args; + args.dbname = &dbname; + args.tbl_name = &tbl_name; + args.new_tbl = &new_tbl; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_alter_table_with_environment_context() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_table_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_alter_table_with_environment_context_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade) +{ + send_alter_table_with_cascade(dbname, tbl_name, new_tbl, cascade); + recv_alter_table_with_cascade(); +} + +void ThriftHiveMetastoreClient::send_alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("alter_table_with_cascade", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_table_with_cascade_pargs args; + args.dbname = &dbname; + args.tbl_name = &tbl_name; + args.new_tbl = &new_tbl; + args.cascade = &cascade; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_alter_table_with_cascade() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_table_with_cascade") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_alter_table_with_cascade_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::alter_table_req(AlterTableResponse& _return, const AlterTableRequest& req) +{ + send_alter_table_req(req); + recv_alter_table_req(_return); +} + +void ThriftHiveMetastoreClient::send_alter_table_req(const AlterTableRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("alter_table_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_table_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_alter_table_req(AlterTableResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_table_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_alter_table_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "alter_table_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::add_partition(Partition& _return, const Partition& new_part) +{ + send_add_partition(new_part); + recv_add_partition(_return); +} + +void ThriftHiveMetastoreClient::send_add_partition(const Partition& new_part) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("add_partition", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_partition_pargs args; + args.new_part = &new_part; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_add_partition(Partition& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_partition") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_add_partition_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "add_partition failed: unknown result"); +} + +void ThriftHiveMetastoreClient::add_partition_with_environment_context(Partition& _return, const Partition& new_part, const EnvironmentContext& environment_context) +{ + send_add_partition_with_environment_context(new_part, environment_context); + recv_add_partition_with_environment_context(_return); +} + +void ThriftHiveMetastoreClient::send_add_partition_with_environment_context(const Partition& new_part, const EnvironmentContext& environment_context) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("add_partition_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_partition_with_environment_context_pargs args; + args.new_part = &new_part; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_add_partition_with_environment_context(Partition& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_partition_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_add_partition_with_environment_context_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "add_partition_with_environment_context failed: unknown result"); +} + +int32_t ThriftHiveMetastoreClient::add_partitions(const std::vector & new_parts) +{ + send_add_partitions(new_parts); + return recv_add_partitions(); +} + +void ThriftHiveMetastoreClient::send_add_partitions(const std::vector & new_parts) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("add_partitions", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_partitions_pargs args; + args.new_parts = &new_parts; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +int32_t ThriftHiveMetastoreClient::recv_add_partitions() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_partitions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + int32_t _return; + ThriftHiveMetastore_add_partitions_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "add_partitions failed: unknown result"); +} + +int32_t ThriftHiveMetastoreClient::add_partitions_pspec(const std::vector & new_parts) +{ + send_add_partitions_pspec(new_parts); + return recv_add_partitions_pspec(); +} + +void ThriftHiveMetastoreClient::send_add_partitions_pspec(const std::vector & new_parts) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("add_partitions_pspec", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_partitions_pspec_pargs args; + args.new_parts = &new_parts; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +int32_t ThriftHiveMetastoreClient::recv_add_partitions_pspec() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_partitions_pspec") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + int32_t _return; + ThriftHiveMetastore_add_partitions_pspec_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "add_partitions_pspec failed: unknown result"); +} + +void ThriftHiveMetastoreClient::append_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals) +{ + send_append_partition(db_name, tbl_name, part_vals); + recv_append_partition(_return); +} + +void ThriftHiveMetastoreClient::send_append_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("append_partition", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_append_partition_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_append_partition(Partition& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("append_partition") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_append_partition_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "append_partition failed: unknown result"); +} + +void ThriftHiveMetastoreClient::add_partitions_req(AddPartitionsResult& _return, const AddPartitionsRequest& request) +{ + send_add_partitions_req(request); + recv_add_partitions_req(_return); +} + +void ThriftHiveMetastoreClient::send_add_partitions_req(const AddPartitionsRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("add_partitions_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_partitions_req_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_add_partitions_req(AddPartitionsResult& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_partitions_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_add_partitions_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "add_partitions_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::append_partition_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const EnvironmentContext& environment_context) +{ + send_append_partition_with_environment_context(db_name, tbl_name, part_vals, environment_context); + recv_append_partition_with_environment_context(_return); +} + +void ThriftHiveMetastoreClient::send_append_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const EnvironmentContext& environment_context) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("append_partition_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_append_partition_with_environment_context_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_append_partition_with_environment_context(Partition& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("append_partition_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_append_partition_with_environment_context_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "append_partition_with_environment_context failed: unknown result"); +} + +void ThriftHiveMetastoreClient::append_partition_req(Partition& _return, const AppendPartitionsRequest& appendPartitionsReq) +{ + send_append_partition_req(appendPartitionsReq); + recv_append_partition_req(_return); +} + +void ThriftHiveMetastoreClient::send_append_partition_req(const AppendPartitionsRequest& appendPartitionsReq) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("append_partition_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_append_partition_req_pargs args; + args.appendPartitionsReq = &appendPartitionsReq; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_append_partition_req(Partition& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("append_partition_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_append_partition_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "append_partition_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::append_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name) +{ + send_append_partition_by_name(db_name, tbl_name, part_name); + recv_append_partition_by_name(_return); +} + +void ThriftHiveMetastoreClient::send_append_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("append_partition_by_name", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_append_partition_by_name_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_name = &part_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_append_partition_by_name(Partition& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("append_partition_by_name") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_append_partition_by_name_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "append_partition_by_name failed: unknown result"); +} + +void ThriftHiveMetastoreClient::append_partition_by_name_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context) +{ + send_append_partition_by_name_with_environment_context(db_name, tbl_name, part_name, environment_context); + recv_append_partition_by_name_with_environment_context(_return); +} + +void ThriftHiveMetastoreClient::send_append_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("append_partition_by_name_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_append_partition_by_name_with_environment_context_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_name = &part_name; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_append_partition_by_name_with_environment_context(Partition& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("append_partition_by_name_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_append_partition_by_name_with_environment_context_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "append_partition_by_name_with_environment_context failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData) +{ + send_drop_partition(db_name, tbl_name, part_vals, deleteData); + return recv_drop_partition(); +} + +void ThriftHiveMetastoreClient::send_drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_partition", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_partition_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.deleteData = &deleteData; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_drop_partition() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_partition") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_drop_partition_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_partition failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::drop_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData, const EnvironmentContext& environment_context) +{ + send_drop_partition_with_environment_context(db_name, tbl_name, part_vals, deleteData, environment_context); + return recv_drop_partition_with_environment_context(); +} + +void ThriftHiveMetastoreClient::send_drop_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData, const EnvironmentContext& environment_context) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_partition_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_partition_with_environment_context_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.deleteData = &deleteData; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_drop_partition_with_environment_context() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_partition_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_drop_partition_with_environment_context_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_partition_with_environment_context failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::drop_partition_req(const DropPartitionRequest& dropPartitionReq) +{ + send_drop_partition_req(dropPartitionReq); + return recv_drop_partition_req(); +} + +void ThriftHiveMetastoreClient::send_drop_partition_req(const DropPartitionRequest& dropPartitionReq) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_partition_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_partition_req_pargs args; + args.dropPartitionReq = &dropPartitionReq; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_drop_partition_req() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_partition_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_drop_partition_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_partition_req failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData) +{ + send_drop_partition_by_name(db_name, tbl_name, part_name, deleteData); + return recv_drop_partition_by_name(); +} + +void ThriftHiveMetastoreClient::send_drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_partition_by_name", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_partition_by_name_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_name = &part_name; + args.deleteData = &deleteData; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_drop_partition_by_name() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_partition_by_name") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_drop_partition_by_name_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_partition_by_name failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::drop_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData, const EnvironmentContext& environment_context) +{ + send_drop_partition_by_name_with_environment_context(db_name, tbl_name, part_name, deleteData, environment_context); + return recv_drop_partition_by_name_with_environment_context(); +} + +void ThriftHiveMetastoreClient::send_drop_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData, const EnvironmentContext& environment_context) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_partition_by_name_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_partition_by_name_with_environment_context_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_name = &part_name; + args.deleteData = &deleteData; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_drop_partition_by_name_with_environment_context() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_partition_by_name_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_drop_partition_by_name_with_environment_context_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_partition_by_name_with_environment_context failed: unknown result"); +} + +void ThriftHiveMetastoreClient::drop_partitions_req(DropPartitionsResult& _return, const DropPartitionsRequest& req) +{ + send_drop_partitions_req(req); + recv_drop_partitions_req(_return); +} + +void ThriftHiveMetastoreClient::send_drop_partitions_req(const DropPartitionsRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_partitions_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_partitions_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_drop_partitions_req(DropPartitionsResult& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_partitions_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_drop_partitions_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_partitions_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals) +{ + send_get_partition(db_name, tbl_name, part_vals); + recv_get_partition(_return); +} + +void ThriftHiveMetastoreClient::send_get_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partition", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partition_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partition(Partition& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partition") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partition_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partition failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partition_req(GetPartitionResponse& _return, const GetPartitionRequest& req) +{ + send_get_partition_req(req); + recv_get_partition_req(_return); +} + +void ThriftHiveMetastoreClient::send_get_partition_req(const GetPartitionRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partition_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partition_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partition_req(GetPartitionResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partition_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partition_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partition_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::exchange_partition(Partition& _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) +{ + send_exchange_partition(partitionSpecs, source_db, source_table_name, dest_db, dest_table_name); + recv_exchange_partition(_return); +} + +void ThriftHiveMetastoreClient::send_exchange_partition(const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("exchange_partition", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_exchange_partition_pargs args; + args.partitionSpecs = &partitionSpecs; + args.source_db = &source_db; + args.source_table_name = &source_table_name; + args.dest_db = &dest_db; + args.dest_table_name = &dest_table_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_exchange_partition(Partition& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("exchange_partition") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_exchange_partition_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "exchange_partition failed: unknown result"); +} + +void ThriftHiveMetastoreClient::exchange_partitions(std::vector & _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) +{ + send_exchange_partitions(partitionSpecs, source_db, source_table_name, dest_db, dest_table_name); + recv_exchange_partitions(_return); +} + +void ThriftHiveMetastoreClient::send_exchange_partitions(const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("exchange_partitions", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_exchange_partitions_pargs args; + args.partitionSpecs = &partitionSpecs; + args.source_db = &source_db; + args.source_table_name = &source_table_name; + args.dest_db = &dest_db; + args.dest_table_name = &dest_table_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_exchange_partitions(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("exchange_partitions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_exchange_partitions_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "exchange_partitions failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partition_with_auth(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const std::string& user_name, const std::vector & group_names) +{ + send_get_partition_with_auth(db_name, tbl_name, part_vals, user_name, group_names); + recv_get_partition_with_auth(_return); +} + +void ThriftHiveMetastoreClient::send_get_partition_with_auth(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const std::string& user_name, const std::vector & group_names) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partition_with_auth", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partition_with_auth_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.user_name = &user_name; + args.group_names = &group_names; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partition_with_auth(Partition& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partition_with_auth") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partition_with_auth_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partition_with_auth failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name) +{ + send_get_partition_by_name(db_name, tbl_name, part_name); + recv_get_partition_by_name(_return); +} + +void ThriftHiveMetastoreClient::send_get_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partition_by_name", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partition_by_name_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_name = &part_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partition_by_name(Partition& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partition_by_name") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partition_by_name_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partition_by_name failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partitions(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts) +{ + send_get_partitions(db_name, tbl_name, max_parts); + recv_get_partitions(_return); +} + +void ThriftHiveMetastoreClient::send_get_partitions(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partitions", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.max_parts = &max_parts; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partitions(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partitions_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partitions_req(PartitionsResponse& _return, const PartitionsRequest& req) +{ + send_get_partitions_req(req); + recv_get_partitions_req(_return); +} + +void ThriftHiveMetastoreClient::send_get_partitions_req(const PartitionsRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partitions_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partitions_req(PartitionsResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partitions_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partitions_with_auth(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts, const std::string& user_name, const std::vector & group_names) +{ + send_get_partitions_with_auth(db_name, tbl_name, max_parts, user_name, group_names); + recv_get_partitions_with_auth(_return); +} + +void ThriftHiveMetastoreClient::send_get_partitions_with_auth(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts, const std::string& user_name, const std::vector & group_names) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partitions_with_auth", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_with_auth_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.max_parts = &max_parts; + args.user_name = &user_name; + args.group_names = &group_names; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partitions_with_auth(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_with_auth") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partitions_with_auth_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_with_auth failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partitions_pspec(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int32_t max_parts) +{ + send_get_partitions_pspec(db_name, tbl_name, max_parts); + recv_get_partitions_pspec(_return); +} + +void ThriftHiveMetastoreClient::send_get_partitions_pspec(const std::string& db_name, const std::string& tbl_name, const int32_t max_parts) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partitions_pspec", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_pspec_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.max_parts = &max_parts; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partitions_pspec(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_pspec") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partitions_pspec_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_pspec failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partition_names(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts) +{ + send_get_partition_names(db_name, tbl_name, max_parts); + recv_get_partition_names(_return); +} + +void ThriftHiveMetastoreClient::send_get_partition_names(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partition_names", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partition_names_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.max_parts = &max_parts; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partition_names(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partition_names") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partition_names_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partition_names failed: unknown result"); +} + +void ThriftHiveMetastoreClient::fetch_partition_names_req(std::vector & _return, const PartitionsRequest& partitionReq) +{ + send_fetch_partition_names_req(partitionReq); + recv_fetch_partition_names_req(_return); +} + +void ThriftHiveMetastoreClient::send_fetch_partition_names_req(const PartitionsRequest& partitionReq) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("fetch_partition_names_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_fetch_partition_names_req_pargs args; + args.partitionReq = &partitionReq; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_fetch_partition_names_req(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("fetch_partition_names_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_fetch_partition_names_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "fetch_partition_names_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partition_values(PartitionValuesResponse& _return, const PartitionValuesRequest& request) +{ + send_get_partition_values(request); + recv_get_partition_values(_return); +} + +void ThriftHiveMetastoreClient::send_get_partition_values(const PartitionValuesRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partition_values", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partition_values_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partition_values(PartitionValuesResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partition_values") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partition_values_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partition_values failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partitions_ps(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts) +{ + send_get_partitions_ps(db_name, tbl_name, part_vals, max_parts); + recv_get_partitions_ps(_return); +} + +void ThriftHiveMetastoreClient::send_get_partitions_ps(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partitions_ps", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_ps_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.max_parts = &max_parts; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partitions_ps(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_ps") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partitions_ps_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_ps failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partitions_ps_with_auth(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts, const std::string& user_name, const std::vector & group_names) +{ + send_get_partitions_ps_with_auth(db_name, tbl_name, part_vals, max_parts, user_name, group_names); + recv_get_partitions_ps_with_auth(_return); +} + +void ThriftHiveMetastoreClient::send_get_partitions_ps_with_auth(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts, const std::string& user_name, const std::vector & group_names) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partitions_ps_with_auth", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_ps_with_auth_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.max_parts = &max_parts; + args.user_name = &user_name; + args.group_names = &group_names; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partitions_ps_with_auth(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_ps_with_auth") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partitions_ps_with_auth_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_ps_with_auth failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partitions_ps_with_auth_req(GetPartitionsPsWithAuthResponse& _return, const GetPartitionsPsWithAuthRequest& req) +{ + send_get_partitions_ps_with_auth_req(req); + recv_get_partitions_ps_with_auth_req(_return); +} + +void ThriftHiveMetastoreClient::send_get_partitions_ps_with_auth_req(const GetPartitionsPsWithAuthRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partitions_ps_with_auth_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_ps_with_auth_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partitions_ps_with_auth_req(GetPartitionsPsWithAuthResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_ps_with_auth_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partitions_ps_with_auth_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_ps_with_auth_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partition_names_ps(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts) +{ + send_get_partition_names_ps(db_name, tbl_name, part_vals, max_parts); + recv_get_partition_names_ps(_return); +} + +void ThriftHiveMetastoreClient::send_get_partition_names_ps(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partition_names_ps", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partition_names_ps_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.max_parts = &max_parts; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partition_names_ps(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partition_names_ps") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partition_names_ps_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partition_names_ps failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partition_names_ps_req(GetPartitionNamesPsResponse& _return, const GetPartitionNamesPsRequest& req) +{ + send_get_partition_names_ps_req(req); + recv_get_partition_names_ps_req(_return); +} + +void ThriftHiveMetastoreClient::send_get_partition_names_ps_req(const GetPartitionNamesPsRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partition_names_ps_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partition_names_ps_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partition_names_ps_req(GetPartitionNamesPsResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partition_names_ps_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partition_names_ps_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partition_names_ps_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partition_names_req(std::vector & _return, const PartitionsByExprRequest& req) +{ + send_get_partition_names_req(req); + recv_get_partition_names_req(_return); +} + +void ThriftHiveMetastoreClient::send_get_partition_names_req(const PartitionsByExprRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partition_names_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partition_names_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partition_names_req(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partition_names_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partition_names_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partition_names_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partitions_by_filter(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int16_t max_parts) +{ + send_get_partitions_by_filter(db_name, tbl_name, filter, max_parts); + recv_get_partitions_by_filter(_return); +} + +void ThriftHiveMetastoreClient::send_get_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int16_t max_parts) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partitions_by_filter", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_by_filter_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.filter = &filter; + args.max_parts = &max_parts; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partitions_by_filter(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_by_filter") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partitions_by_filter_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_by_filter failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partitions_by_filter_req(std::vector & _return, const GetPartitionsByFilterRequest& req) +{ + send_get_partitions_by_filter_req(req); + recv_get_partitions_by_filter_req(_return); +} + +void ThriftHiveMetastoreClient::send_get_partitions_by_filter_req(const GetPartitionsByFilterRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partitions_by_filter_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_by_filter_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partitions_by_filter_req(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_by_filter_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partitions_by_filter_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_by_filter_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_part_specs_by_filter(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int32_t max_parts) +{ + send_get_part_specs_by_filter(db_name, tbl_name, filter, max_parts); + recv_get_part_specs_by_filter(_return); +} + +void ThriftHiveMetastoreClient::send_get_part_specs_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int32_t max_parts) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_part_specs_by_filter", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_part_specs_by_filter_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.filter = &filter; + args.max_parts = &max_parts; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_part_specs_by_filter(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_part_specs_by_filter") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_part_specs_by_filter_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_part_specs_by_filter failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partitions_by_expr(PartitionsByExprResult& _return, const PartitionsByExprRequest& req) +{ + send_get_partitions_by_expr(req); + recv_get_partitions_by_expr(_return); +} + +void ThriftHiveMetastoreClient::send_get_partitions_by_expr(const PartitionsByExprRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partitions_by_expr", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_by_expr_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partitions_by_expr(PartitionsByExprResult& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_by_expr") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partitions_by_expr_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_by_expr failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partitions_spec_by_expr(PartitionsSpecByExprResult& _return, const PartitionsByExprRequest& req) +{ + send_get_partitions_spec_by_expr(req); + recv_get_partitions_spec_by_expr(_return); +} + +void ThriftHiveMetastoreClient::send_get_partitions_spec_by_expr(const PartitionsByExprRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partitions_spec_by_expr", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_spec_by_expr_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partitions_spec_by_expr(PartitionsSpecByExprResult& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_spec_by_expr") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partitions_spec_by_expr_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_spec_by_expr failed: unknown result"); +} + +int32_t ThriftHiveMetastoreClient::get_num_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter) +{ + send_get_num_partitions_by_filter(db_name, tbl_name, filter); + return recv_get_num_partitions_by_filter(); +} + +void ThriftHiveMetastoreClient::send_get_num_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_num_partitions_by_filter", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_num_partitions_by_filter_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.filter = &filter; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +int32_t ThriftHiveMetastoreClient::recv_get_num_partitions_by_filter() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_num_partitions_by_filter") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + int32_t _return; + ThriftHiveMetastore_get_num_partitions_by_filter_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_num_partitions_by_filter failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partitions_by_names(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & names) +{ + send_get_partitions_by_names(db_name, tbl_name, names); + recv_get_partitions_by_names(_return); +} + +void ThriftHiveMetastoreClient::send_get_partitions_by_names(const std::string& db_name, const std::string& tbl_name, const std::vector & names) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partitions_by_names", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_by_names_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.names = &names; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partitions_by_names(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_by_names") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partitions_by_names_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_by_names failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partitions_by_names_req(GetPartitionsByNamesResult& _return, const GetPartitionsByNamesRequest& req) +{ + send_get_partitions_by_names_req(req); + recv_get_partitions_by_names_req(_return); +} + +void ThriftHiveMetastoreClient::send_get_partitions_by_names_req(const GetPartitionsByNamesRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partitions_by_names_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_by_names_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partitions_by_names_req(GetPartitionsByNamesResult& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_by_names_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partitions_by_names_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_by_names_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_properties(PropertyGetResponse& _return, const PropertyGetRequest& req) +{ + send_get_properties(req); + recv_get_properties(_return); +} + +void ThriftHiveMetastoreClient::send_get_properties(const PropertyGetRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_properties", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_properties_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_properties(PropertyGetResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_properties") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_properties_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.e1) { + throw result.e1; + } + if (result.__isset.e2) { + throw result.e2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_properties failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::set_properties(const PropertySetRequest& req) +{ + send_set_properties(req); + return recv_set_properties(); +} + +void ThriftHiveMetastoreClient::send_set_properties(const PropertySetRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("set_properties", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_set_properties_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_set_properties() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("set_properties") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_set_properties_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.e1) { + throw result.e1; + } + if (result.__isset.e2) { + throw result.e2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "set_properties failed: unknown result"); +} + +void ThriftHiveMetastoreClient::alter_partition(const std::string& db_name, const std::string& tbl_name, const Partition& new_part) +{ + send_alter_partition(db_name, tbl_name, new_part); + recv_alter_partition(); +} + +void ThriftHiveMetastoreClient::send_alter_partition(const std::string& db_name, const std::string& tbl_name, const Partition& new_part) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("alter_partition", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_partition_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.new_part = &new_part; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_alter_partition() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_partition") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_alter_partition_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts) +{ + send_alter_partitions(db_name, tbl_name, new_parts); + recv_alter_partitions(); +} + +void ThriftHiveMetastoreClient::send_alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("alter_partitions", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_partitions_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.new_parts = &new_parts; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_alter_partitions() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_partitions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_alter_partitions_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::alter_partitions_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts, const EnvironmentContext& environment_context) +{ + send_alter_partitions_with_environment_context(db_name, tbl_name, new_parts, environment_context); + recv_alter_partitions_with_environment_context(); +} + +void ThriftHiveMetastoreClient::send_alter_partitions_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts, const EnvironmentContext& environment_context) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("alter_partitions_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_partitions_with_environment_context_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.new_parts = &new_parts; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_alter_partitions_with_environment_context() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_partitions_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_alter_partitions_with_environment_context_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::alter_partitions_req(AlterPartitionsResponse& _return, const AlterPartitionsRequest& req) +{ + send_alter_partitions_req(req); + recv_alter_partitions_req(_return); +} + +void ThriftHiveMetastoreClient::send_alter_partitions_req(const AlterPartitionsRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("alter_partitions_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_partitions_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_alter_partitions_req(AlterPartitionsResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_partitions_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_alter_partitions_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "alter_partitions_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context) +{ + send_alter_partition_with_environment_context(db_name, tbl_name, new_part, environment_context); + recv_alter_partition_with_environment_context(); +} + +void ThriftHiveMetastoreClient::send_alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("alter_partition_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_partition_with_environment_context_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.new_part = &new_part; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_alter_partition_with_environment_context() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_partition_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_alter_partition_with_environment_context_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const Partition& new_part) +{ + send_rename_partition(db_name, tbl_name, part_vals, new_part); + recv_rename_partition(); +} + +void ThriftHiveMetastoreClient::send_rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const Partition& new_part) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("rename_partition", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_rename_partition_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.new_part = &new_part; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_rename_partition() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("rename_partition") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_rename_partition_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::rename_partition_req(RenamePartitionResponse& _return, const RenamePartitionRequest& req) +{ + send_rename_partition_req(req); + recv_rename_partition_req(_return); +} + +void ThriftHiveMetastoreClient::send_rename_partition_req(const RenamePartitionRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("rename_partition_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_rename_partition_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_rename_partition_req(RenamePartitionResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("rename_partition_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_rename_partition_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "rename_partition_req failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::partition_name_has_valid_characters(const std::vector & part_vals, const bool throw_exception) +{ + send_partition_name_has_valid_characters(part_vals, throw_exception); + return recv_partition_name_has_valid_characters(); +} + +void ThriftHiveMetastoreClient::send_partition_name_has_valid_characters(const std::vector & part_vals, const bool throw_exception) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("partition_name_has_valid_characters", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_partition_name_has_valid_characters_pargs args; + args.part_vals = &part_vals; + args.throw_exception = &throw_exception; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_partition_name_has_valid_characters() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("partition_name_has_valid_characters") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_partition_name_has_valid_characters_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "partition_name_has_valid_characters failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_config_value(std::string& _return, const std::string& name, const std::string& defaultValue) +{ + send_get_config_value(name, defaultValue); + recv_get_config_value(_return); +} + +void ThriftHiveMetastoreClient::send_get_config_value(const std::string& name, const std::string& defaultValue) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_config_value", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_config_value_pargs args; + args.name = &name; + args.defaultValue = &defaultValue; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_config_value(std::string& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_config_value") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_config_value_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_config_value failed: unknown result"); +} + +void ThriftHiveMetastoreClient::partition_name_to_vals(std::vector & _return, const std::string& part_name) +{ + send_partition_name_to_vals(part_name); + recv_partition_name_to_vals(_return); +} + +void ThriftHiveMetastoreClient::send_partition_name_to_vals(const std::string& part_name) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("partition_name_to_vals", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_partition_name_to_vals_pargs args; + args.part_name = &part_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_partition_name_to_vals(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("partition_name_to_vals") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_partition_name_to_vals_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "partition_name_to_vals failed: unknown result"); +} + +void ThriftHiveMetastoreClient::partition_name_to_spec(std::map & _return, const std::string& part_name) +{ + send_partition_name_to_spec(part_name); + recv_partition_name_to_spec(_return); +} + +void ThriftHiveMetastoreClient::send_partition_name_to_spec(const std::string& part_name) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("partition_name_to_spec", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_partition_name_to_spec_pargs args; + args.part_name = &part_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_partition_name_to_spec(std::map & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("partition_name_to_spec") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_partition_name_to_spec_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "partition_name_to_spec failed: unknown result"); +} + +void ThriftHiveMetastoreClient::markPartitionForEvent(const std::string& db_name, const std::string& tbl_name, const std::map & part_vals, const PartitionEventType::type eventType) +{ + send_markPartitionForEvent(db_name, tbl_name, part_vals, eventType); + recv_markPartitionForEvent(); +} + +void ThriftHiveMetastoreClient::send_markPartitionForEvent(const std::string& db_name, const std::string& tbl_name, const std::map & part_vals, const PartitionEventType::type eventType) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("markPartitionForEvent", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_markPartitionForEvent_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.eventType = &eventType; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_markPartitionForEvent() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("markPartitionForEvent") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_markPartitionForEvent_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + if (result.__isset.o5) { + throw result.o5; + } + if (result.__isset.o6) { + throw result.o6; + } + return; +} + +bool ThriftHiveMetastoreClient::isPartitionMarkedForEvent(const std::string& db_name, const std::string& tbl_name, const std::map & part_vals, const PartitionEventType::type eventType) +{ + send_isPartitionMarkedForEvent(db_name, tbl_name, part_vals, eventType); + return recv_isPartitionMarkedForEvent(); +} + +void ThriftHiveMetastoreClient::send_isPartitionMarkedForEvent(const std::string& db_name, const std::string& tbl_name, const std::map & part_vals, const PartitionEventType::type eventType) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("isPartitionMarkedForEvent", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_isPartitionMarkedForEvent_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.eventType = &eventType; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_isPartitionMarkedForEvent() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("isPartitionMarkedForEvent") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_isPartitionMarkedForEvent_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + if (result.__isset.o5) { + throw result.o5; + } + if (result.__isset.o6) { + throw result.o6; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "isPartitionMarkedForEvent failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_primary_keys(PrimaryKeysResponse& _return, const PrimaryKeysRequest& request) +{ + send_get_primary_keys(request); + recv_get_primary_keys(_return); +} + +void ThriftHiveMetastoreClient::send_get_primary_keys(const PrimaryKeysRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_primary_keys", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_primary_keys_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_primary_keys(PrimaryKeysResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_primary_keys") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_primary_keys_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_primary_keys failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_foreign_keys(ForeignKeysResponse& _return, const ForeignKeysRequest& request) +{ + send_get_foreign_keys(request); + recv_get_foreign_keys(_return); +} + +void ThriftHiveMetastoreClient::send_get_foreign_keys(const ForeignKeysRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_foreign_keys", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_foreign_keys_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_foreign_keys(ForeignKeysResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_foreign_keys") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_foreign_keys_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_foreign_keys failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_unique_constraints(UniqueConstraintsResponse& _return, const UniqueConstraintsRequest& request) +{ + send_get_unique_constraints(request); + recv_get_unique_constraints(_return); +} + +void ThriftHiveMetastoreClient::send_get_unique_constraints(const UniqueConstraintsRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_unique_constraints", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_unique_constraints_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_unique_constraints(UniqueConstraintsResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_unique_constraints") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_unique_constraints_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_unique_constraints failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_not_null_constraints(NotNullConstraintsResponse& _return, const NotNullConstraintsRequest& request) +{ + send_get_not_null_constraints(request); + recv_get_not_null_constraints(_return); +} + +void ThriftHiveMetastoreClient::send_get_not_null_constraints(const NotNullConstraintsRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_not_null_constraints", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_not_null_constraints_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_not_null_constraints(NotNullConstraintsResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_not_null_constraints") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_not_null_constraints_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_not_null_constraints failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_default_constraints(DefaultConstraintsResponse& _return, const DefaultConstraintsRequest& request) +{ + send_get_default_constraints(request); + recv_get_default_constraints(_return); +} + +void ThriftHiveMetastoreClient::send_get_default_constraints(const DefaultConstraintsRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_default_constraints", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_default_constraints_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_default_constraints(DefaultConstraintsResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_default_constraints") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_default_constraints_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_default_constraints failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_check_constraints(CheckConstraintsResponse& _return, const CheckConstraintsRequest& request) +{ + send_get_check_constraints(request); + recv_get_check_constraints(_return); +} + +void ThriftHiveMetastoreClient::send_get_check_constraints(const CheckConstraintsRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_check_constraints", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_check_constraints_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_check_constraints(CheckConstraintsResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_check_constraints") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_check_constraints_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_check_constraints failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_all_table_constraints(AllTableConstraintsResponse& _return, const AllTableConstraintsRequest& request) +{ + send_get_all_table_constraints(request); + recv_get_all_table_constraints(_return); +} + +void ThriftHiveMetastoreClient::send_get_all_table_constraints(const AllTableConstraintsRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_all_table_constraints", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_all_table_constraints_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_all_table_constraints(AllTableConstraintsResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_all_table_constraints") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_all_table_constraints_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_table_constraints failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::update_table_column_statistics(const ColumnStatistics& stats_obj) +{ + send_update_table_column_statistics(stats_obj); + return recv_update_table_column_statistics(); +} + +void ThriftHiveMetastoreClient::send_update_table_column_statistics(const ColumnStatistics& stats_obj) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("update_table_column_statistics", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_update_table_column_statistics_pargs args; + args.stats_obj = &stats_obj; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_update_table_column_statistics() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("update_table_column_statistics") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_update_table_column_statistics_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "update_table_column_statistics failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::update_partition_column_statistics(const ColumnStatistics& stats_obj) +{ + send_update_partition_column_statistics(stats_obj); + return recv_update_partition_column_statistics(); +} + +void ThriftHiveMetastoreClient::send_update_partition_column_statistics(const ColumnStatistics& stats_obj) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("update_partition_column_statistics", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_update_partition_column_statistics_pargs args; + args.stats_obj = &stats_obj; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_update_partition_column_statistics() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("update_partition_column_statistics") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_update_partition_column_statistics_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "update_partition_column_statistics failed: unknown result"); +} + +void ThriftHiveMetastoreClient::update_table_column_statistics_req(SetPartitionsStatsResponse& _return, const SetPartitionsStatsRequest& req) +{ + send_update_table_column_statistics_req(req); + recv_update_table_column_statistics_req(_return); +} + +void ThriftHiveMetastoreClient::send_update_table_column_statistics_req(const SetPartitionsStatsRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("update_table_column_statistics_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_update_table_column_statistics_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_update_table_column_statistics_req(SetPartitionsStatsResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("update_table_column_statistics_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_update_table_column_statistics_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "update_table_column_statistics_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::update_partition_column_statistics_req(SetPartitionsStatsResponse& _return, const SetPartitionsStatsRequest& req) +{ + send_update_partition_column_statistics_req(req); + recv_update_partition_column_statistics_req(_return); +} + +void ThriftHiveMetastoreClient::send_update_partition_column_statistics_req(const SetPartitionsStatsRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("update_partition_column_statistics_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_update_partition_column_statistics_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_update_partition_column_statistics_req(SetPartitionsStatsResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("update_partition_column_statistics_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_update_partition_column_statistics_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "update_partition_column_statistics_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::update_transaction_statistics(const UpdateTransactionalStatsRequest& req) +{ + send_update_transaction_statistics(req); + recv_update_transaction_statistics(); +} + +void ThriftHiveMetastoreClient::send_update_transaction_statistics(const UpdateTransactionalStatsRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("update_transaction_statistics", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_update_transaction_statistics_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_update_transaction_statistics() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("update_transaction_statistics") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_update_transaction_statistics_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + return; +} + +void ThriftHiveMetastoreClient::get_table_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& col_name) +{ + send_get_table_column_statistics(db_name, tbl_name, col_name); + recv_get_table_column_statistics(_return); +} + +void ThriftHiveMetastoreClient::send_get_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_table_column_statistics", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_table_column_statistics_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.col_name = &col_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_table_column_statistics(ColumnStatistics& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_table_column_statistics") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_table_column_statistics_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_table_column_statistics failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partition_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name) +{ + send_get_partition_column_statistics(db_name, tbl_name, part_name, col_name); + recv_get_partition_column_statistics(_return); +} + +void ThriftHiveMetastoreClient::send_get_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partition_column_statistics", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partition_column_statistics_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_name = &part_name; + args.col_name = &col_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partition_column_statistics(ColumnStatistics& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partition_column_statistics") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partition_column_statistics_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partition_column_statistics failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_table_statistics_req(TableStatsResult& _return, const TableStatsRequest& request) +{ + send_get_table_statistics_req(request); + recv_get_table_statistics_req(_return); +} + +void ThriftHiveMetastoreClient::send_get_table_statistics_req(const TableStatsRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_table_statistics_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_table_statistics_req_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_table_statistics_req(TableStatsResult& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_table_statistics_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_table_statistics_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_table_statistics_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partitions_statistics_req(PartitionsStatsResult& _return, const PartitionsStatsRequest& request) +{ + send_get_partitions_statistics_req(request); + recv_get_partitions_statistics_req(_return); +} + +void ThriftHiveMetastoreClient::send_get_partitions_statistics_req(const PartitionsStatsRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partitions_statistics_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_statistics_req_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partitions_statistics_req(PartitionsStatsResult& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_statistics_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partitions_statistics_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_statistics_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_aggr_stats_for(AggrStats& _return, const PartitionsStatsRequest& request) +{ + send_get_aggr_stats_for(request); + recv_get_aggr_stats_for(_return); +} + +void ThriftHiveMetastoreClient::send_get_aggr_stats_for(const PartitionsStatsRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_aggr_stats_for", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_aggr_stats_for_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_aggr_stats_for(AggrStats& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_aggr_stats_for") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_aggr_stats_for_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_aggr_stats_for failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::set_aggr_stats_for(const SetPartitionsStatsRequest& request) +{ + send_set_aggr_stats_for(request); + return recv_set_aggr_stats_for(); +} + +void ThriftHiveMetastoreClient::send_set_aggr_stats_for(const SetPartitionsStatsRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("set_aggr_stats_for", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_set_aggr_stats_for_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_set_aggr_stats_for() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("set_aggr_stats_for") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_set_aggr_stats_for_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "set_aggr_stats_for failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::delete_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name, const std::string& engine) +{ + send_delete_partition_column_statistics(db_name, tbl_name, part_name, col_name, engine); + return recv_delete_partition_column_statistics(); +} + +void ThriftHiveMetastoreClient::send_delete_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name, const std::string& engine) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("delete_partition_column_statistics", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_delete_partition_column_statistics_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_name = &part_name; + args.col_name = &col_name; + args.engine = &engine; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_delete_partition_column_statistics() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("delete_partition_column_statistics") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_delete_partition_column_statistics_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "delete_partition_column_statistics failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::delete_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name, const std::string& engine) +{ + send_delete_table_column_statistics(db_name, tbl_name, col_name, engine); + return recv_delete_table_column_statistics(); +} + +void ThriftHiveMetastoreClient::send_delete_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name, const std::string& engine) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("delete_table_column_statistics", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_delete_table_column_statistics_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.col_name = &col_name; + args.engine = &engine; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_delete_table_column_statistics() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("delete_table_column_statistics") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_delete_table_column_statistics_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "delete_table_column_statistics failed: unknown result"); +} + +void ThriftHiveMetastoreClient::create_function(const Function& func) +{ + send_create_function(func); + recv_create_function(); +} + +void ThriftHiveMetastoreClient::send_create_function(const Function& func) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("create_function", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_function_pargs args; + args.func = &func; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_create_function() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_function") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_create_function_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + return; +} + +void ThriftHiveMetastoreClient::drop_function(const std::string& dbName, const std::string& funcName) +{ + send_drop_function(dbName, funcName); + recv_drop_function(); +} + +void ThriftHiveMetastoreClient::send_drop_function(const std::string& dbName, const std::string& funcName) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_function", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_function_pargs args; + args.dbName = &dbName; + args.funcName = &funcName; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_drop_function() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_function") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_drop_function_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o3) { + throw result.o3; + } + return; +} + +void ThriftHiveMetastoreClient::alter_function(const std::string& dbName, const std::string& funcName, const Function& newFunc) +{ + send_alter_function(dbName, funcName, newFunc); + recv_alter_function(); +} + +void ThriftHiveMetastoreClient::send_alter_function(const std::string& dbName, const std::string& funcName, const Function& newFunc) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("alter_function", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_function_pargs args; + args.dbName = &dbName; + args.funcName = &funcName; + args.newFunc = &newFunc; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_alter_function() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_function") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_alter_function_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::get_functions(std::vector & _return, const std::string& dbName, const std::string& pattern) +{ + send_get_functions(dbName, pattern); + recv_get_functions(_return); +} + +void ThriftHiveMetastoreClient::send_get_functions(const std::string& dbName, const std::string& pattern) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_functions", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_functions_pargs args; + args.dbName = &dbName; + args.pattern = &pattern; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_functions(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_functions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_functions_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_functions failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_function(Function& _return, const std::string& dbName, const std::string& funcName) +{ + send_get_function(dbName, funcName); + recv_get_function(_return); +} + +void ThriftHiveMetastoreClient::send_get_function(const std::string& dbName, const std::string& funcName) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_function", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_function_pargs args; + args.dbName = &dbName; + args.funcName = &funcName; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_function(Function& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_function") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_function_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_function failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_all_functions(GetAllFunctionsResponse& _return) +{ + send_get_all_functions(); + recv_get_all_functions(_return); +} + +void ThriftHiveMetastoreClient::send_get_all_functions() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_all_functions", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_all_functions_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_all_functions(GetAllFunctionsResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_all_functions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_all_functions_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_functions failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::create_role(const Role& role) +{ + send_create_role(role); + return recv_create_role(); +} + +void ThriftHiveMetastoreClient::send_create_role(const Role& role) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("create_role", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_role_pargs args; + args.role = &role; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_create_role() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_role") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_create_role_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "create_role failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::drop_role(const std::string& role_name) +{ + send_drop_role(role_name); + return recv_drop_role(); +} + +void ThriftHiveMetastoreClient::send_drop_role(const std::string& role_name) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_role", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_role_pargs args; + args.role_name = &role_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_drop_role() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_role") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_drop_role_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_role failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_role_names(std::vector & _return) +{ + send_get_role_names(); + recv_get_role_names(_return); +} + +void ThriftHiveMetastoreClient::send_get_role_names() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_role_names", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_role_names_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_role_names(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_role_names") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_role_names_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_role_names failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::grant_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type, const std::string& grantor, const PrincipalType::type grantorType, const bool grant_option) +{ + send_grant_role(role_name, principal_name, principal_type, grantor, grantorType, grant_option); + return recv_grant_role(); +} + +void ThriftHiveMetastoreClient::send_grant_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type, const std::string& grantor, const PrincipalType::type grantorType, const bool grant_option) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("grant_role", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_grant_role_pargs args; + args.role_name = &role_name; + args.principal_name = &principal_name; + args.principal_type = &principal_type; + args.grantor = &grantor; + args.grantorType = &grantorType; + args.grant_option = &grant_option; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_grant_role() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("grant_role") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_grant_role_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "grant_role failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::revoke_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type) +{ + send_revoke_role(role_name, principal_name, principal_type); + return recv_revoke_role(); +} + +void ThriftHiveMetastoreClient::send_revoke_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("revoke_role", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_revoke_role_pargs args; + args.role_name = &role_name; + args.principal_name = &principal_name; + args.principal_type = &principal_type; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_revoke_role() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("revoke_role") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_revoke_role_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "revoke_role failed: unknown result"); +} + +void ThriftHiveMetastoreClient::list_roles(std::vector & _return, const std::string& principal_name, const PrincipalType::type principal_type) +{ + send_list_roles(principal_name, principal_type); + recv_list_roles(_return); +} + +void ThriftHiveMetastoreClient::send_list_roles(const std::string& principal_name, const PrincipalType::type principal_type) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("list_roles", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_list_roles_pargs args; + args.principal_name = &principal_name; + args.principal_type = &principal_type; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_list_roles(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("list_roles") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_list_roles_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "list_roles failed: unknown result"); +} + +void ThriftHiveMetastoreClient::grant_revoke_role(GrantRevokeRoleResponse& _return, const GrantRevokeRoleRequest& request) +{ + send_grant_revoke_role(request); + recv_grant_revoke_role(_return); +} + +void ThriftHiveMetastoreClient::send_grant_revoke_role(const GrantRevokeRoleRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("grant_revoke_role", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_grant_revoke_role_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_grant_revoke_role(GrantRevokeRoleResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("grant_revoke_role") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_grant_revoke_role_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "grant_revoke_role failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_principals_in_role(GetPrincipalsInRoleResponse& _return, const GetPrincipalsInRoleRequest& request) +{ + send_get_principals_in_role(request); + recv_get_principals_in_role(_return); +} + +void ThriftHiveMetastoreClient::send_get_principals_in_role(const GetPrincipalsInRoleRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_principals_in_role", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_principals_in_role_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_principals_in_role(GetPrincipalsInRoleResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_principals_in_role") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_principals_in_role_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_principals_in_role failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& _return, const GetRoleGrantsForPrincipalRequest& request) +{ + send_get_role_grants_for_principal(request); + recv_get_role_grants_for_principal(_return); +} + +void ThriftHiveMetastoreClient::send_get_role_grants_for_principal(const GetRoleGrantsForPrincipalRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_role_grants_for_principal", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_role_grants_for_principal_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_role_grants_for_principal") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_role_grants_for_principal_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_role_grants_for_principal failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_privilege_set(PrincipalPrivilegeSet& _return, const HiveObjectRef& hiveObject, const std::string& user_name, const std::vector & group_names) +{ + send_get_privilege_set(hiveObject, user_name, group_names); + recv_get_privilege_set(_return); +} + +void ThriftHiveMetastoreClient::send_get_privilege_set(const HiveObjectRef& hiveObject, const std::string& user_name, const std::vector & group_names) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_privilege_set", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_privilege_set_pargs args; + args.hiveObject = &hiveObject; + args.user_name = &user_name; + args.group_names = &group_names; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_privilege_set(PrincipalPrivilegeSet& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_privilege_set") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_privilege_set_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_privilege_set failed: unknown result"); +} + +void ThriftHiveMetastoreClient::list_privileges(std::vector & _return, const std::string& principal_name, const PrincipalType::type principal_type, const HiveObjectRef& hiveObject) +{ + send_list_privileges(principal_name, principal_type, hiveObject); + recv_list_privileges(_return); +} + +void ThriftHiveMetastoreClient::send_list_privileges(const std::string& principal_name, const PrincipalType::type principal_type, const HiveObjectRef& hiveObject) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("list_privileges", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_list_privileges_pargs args; + args.principal_name = &principal_name; + args.principal_type = &principal_type; + args.hiveObject = &hiveObject; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_list_privileges(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("list_privileges") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_list_privileges_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "list_privileges failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::grant_privileges(const PrivilegeBag& privileges) +{ + send_grant_privileges(privileges); + return recv_grant_privileges(); +} + +void ThriftHiveMetastoreClient::send_grant_privileges(const PrivilegeBag& privileges) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("grant_privileges", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_grant_privileges_pargs args; + args.privileges = &privileges; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_grant_privileges() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("grant_privileges") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_grant_privileges_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "grant_privileges failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::revoke_privileges(const PrivilegeBag& privileges) +{ + send_revoke_privileges(privileges); + return recv_revoke_privileges(); +} + +void ThriftHiveMetastoreClient::send_revoke_privileges(const PrivilegeBag& privileges) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("revoke_privileges", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_revoke_privileges_pargs args; + args.privileges = &privileges; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_revoke_privileges() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("revoke_privileges") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_revoke_privileges_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "revoke_privileges failed: unknown result"); +} + +void ThriftHiveMetastoreClient::grant_revoke_privileges(GrantRevokePrivilegeResponse& _return, const GrantRevokePrivilegeRequest& request) +{ + send_grant_revoke_privileges(request); + recv_grant_revoke_privileges(_return); +} + +void ThriftHiveMetastoreClient::send_grant_revoke_privileges(const GrantRevokePrivilegeRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("grant_revoke_privileges", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_grant_revoke_privileges_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_grant_revoke_privileges(GrantRevokePrivilegeResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("grant_revoke_privileges") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_grant_revoke_privileges_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "grant_revoke_privileges failed: unknown result"); +} + +void ThriftHiveMetastoreClient::refresh_privileges(GrantRevokePrivilegeResponse& _return, const HiveObjectRef& objToRefresh, const std::string& authorizer, const GrantRevokePrivilegeRequest& grantRequest) +{ + send_refresh_privileges(objToRefresh, authorizer, grantRequest); + recv_refresh_privileges(_return); +} + +void ThriftHiveMetastoreClient::send_refresh_privileges(const HiveObjectRef& objToRefresh, const std::string& authorizer, const GrantRevokePrivilegeRequest& grantRequest) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("refresh_privileges", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_refresh_privileges_pargs args; + args.objToRefresh = &objToRefresh; + args.authorizer = &authorizer; + args.grantRequest = &grantRequest; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_refresh_privileges(GrantRevokePrivilegeResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("refresh_privileges") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_refresh_privileges_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "refresh_privileges failed: unknown result"); +} + +void ThriftHiveMetastoreClient::set_ugi(std::vector & _return, const std::string& user_name, const std::vector & group_names) +{ + send_set_ugi(user_name, group_names); + recv_set_ugi(_return); +} + +void ThriftHiveMetastoreClient::send_set_ugi(const std::string& user_name, const std::vector & group_names) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("set_ugi", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_set_ugi_pargs args; + args.user_name = &user_name; + args.group_names = &group_names; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_set_ugi(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("set_ugi") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_set_ugi_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "set_ugi failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_delegation_token(std::string& _return, const std::string& token_owner, const std::string& renewer_kerberos_principal_name) +{ + send_get_delegation_token(token_owner, renewer_kerberos_principal_name); + recv_get_delegation_token(_return); +} + +void ThriftHiveMetastoreClient::send_get_delegation_token(const std::string& token_owner, const std::string& renewer_kerberos_principal_name) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_delegation_token", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_delegation_token_pargs args; + args.token_owner = &token_owner; + args.renewer_kerberos_principal_name = &renewer_kerberos_principal_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_delegation_token(std::string& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_delegation_token") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_delegation_token_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_delegation_token failed: unknown result"); +} + +int64_t ThriftHiveMetastoreClient::renew_delegation_token(const std::string& token_str_form) +{ + send_renew_delegation_token(token_str_form); + return recv_renew_delegation_token(); +} + +void ThriftHiveMetastoreClient::send_renew_delegation_token(const std::string& token_str_form) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("renew_delegation_token", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_renew_delegation_token_pargs args; + args.token_str_form = &token_str_form; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +int64_t ThriftHiveMetastoreClient::recv_renew_delegation_token() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("renew_delegation_token") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + int64_t _return; + ThriftHiveMetastore_renew_delegation_token_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "renew_delegation_token failed: unknown result"); +} + +void ThriftHiveMetastoreClient::cancel_delegation_token(const std::string& token_str_form) +{ + send_cancel_delegation_token(token_str_form); + recv_cancel_delegation_token(); +} + +void ThriftHiveMetastoreClient::send_cancel_delegation_token(const std::string& token_str_form) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("cancel_delegation_token", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_cancel_delegation_token_pargs args; + args.token_str_form = &token_str_form; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_cancel_delegation_token() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("cancel_delegation_token") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_cancel_delegation_token_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + return; +} + +bool ThriftHiveMetastoreClient::add_token(const std::string& token_identifier, const std::string& delegation_token) +{ + send_add_token(token_identifier, delegation_token); + return recv_add_token(); +} + +void ThriftHiveMetastoreClient::send_add_token(const std::string& token_identifier, const std::string& delegation_token) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("add_token", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_token_pargs args; + args.token_identifier = &token_identifier; + args.delegation_token = &delegation_token; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_add_token() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_token") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_add_token_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "add_token failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::remove_token(const std::string& token_identifier) +{ + send_remove_token(token_identifier); + return recv_remove_token(); +} + +void ThriftHiveMetastoreClient::send_remove_token(const std::string& token_identifier) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("remove_token", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_remove_token_pargs args; + args.token_identifier = &token_identifier; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_remove_token() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("remove_token") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_remove_token_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "remove_token failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_token(std::string& _return, const std::string& token_identifier) +{ + send_get_token(token_identifier); + recv_get_token(_return); +} + +void ThriftHiveMetastoreClient::send_get_token(const std::string& token_identifier) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_token", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_token_pargs args; + args.token_identifier = &token_identifier; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_token(std::string& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_token") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_token_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_token failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_all_token_identifiers(std::vector & _return) +{ + send_get_all_token_identifiers(); + recv_get_all_token_identifiers(_return); +} + +void ThriftHiveMetastoreClient::send_get_all_token_identifiers() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_all_token_identifiers", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_all_token_identifiers_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_all_token_identifiers(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_all_token_identifiers") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_all_token_identifiers_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_token_identifiers failed: unknown result"); +} + +int32_t ThriftHiveMetastoreClient::add_master_key(const std::string& key) +{ + send_add_master_key(key); + return recv_add_master_key(); +} + +void ThriftHiveMetastoreClient::send_add_master_key(const std::string& key) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("add_master_key", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_master_key_pargs args; + args.key = &key; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +int32_t ThriftHiveMetastoreClient::recv_add_master_key() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_master_key") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + int32_t _return; + ThriftHiveMetastore_add_master_key_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "add_master_key failed: unknown result"); +} + +void ThriftHiveMetastoreClient::update_master_key(const int32_t seq_number, const std::string& key) +{ + send_update_master_key(seq_number, key); + recv_update_master_key(); +} + +void ThriftHiveMetastoreClient::send_update_master_key(const int32_t seq_number, const std::string& key) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("update_master_key", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_update_master_key_pargs args; + args.seq_number = &seq_number; + args.key = &key; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_update_master_key() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("update_master_key") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_update_master_key_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +bool ThriftHiveMetastoreClient::remove_master_key(const int32_t key_seq) +{ + send_remove_master_key(key_seq); + return recv_remove_master_key(); +} + +void ThriftHiveMetastoreClient::send_remove_master_key(const int32_t key_seq) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("remove_master_key", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_remove_master_key_pargs args; + args.key_seq = &key_seq; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_remove_master_key() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("remove_master_key") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_remove_master_key_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "remove_master_key failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_master_keys(std::vector & _return) +{ + send_get_master_keys(); + recv_get_master_keys(_return); +} + +void ThriftHiveMetastoreClient::send_get_master_keys() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_master_keys", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_master_keys_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_master_keys(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_master_keys") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_master_keys_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_master_keys failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_open_txns(GetOpenTxnsResponse& _return) +{ + send_get_open_txns(); + recv_get_open_txns(_return); +} + +void ThriftHiveMetastoreClient::send_get_open_txns() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_open_txns", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_open_txns_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_open_txns(GetOpenTxnsResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_open_txns") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_open_txns_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_open_txns failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_open_txns_info(GetOpenTxnsInfoResponse& _return) +{ + send_get_open_txns_info(); + recv_get_open_txns_info(_return); +} + +void ThriftHiveMetastoreClient::send_get_open_txns_info() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_open_txns_info", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_open_txns_info_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_open_txns_info(GetOpenTxnsInfoResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_open_txns_info") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_open_txns_info_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_open_txns_info failed: unknown result"); +} + +void ThriftHiveMetastoreClient::open_txns(OpenTxnsResponse& _return, const OpenTxnRequest& rqst) +{ + send_open_txns(rqst); + recv_open_txns(_return); +} + +void ThriftHiveMetastoreClient::send_open_txns(const OpenTxnRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("open_txns", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_open_txns_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_open_txns(OpenTxnsResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("open_txns") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_open_txns_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "open_txns failed: unknown result"); +} + +void ThriftHiveMetastoreClient::abort_txn(const AbortTxnRequest& rqst) +{ + send_abort_txn(rqst); + recv_abort_txn(); +} + +void ThriftHiveMetastoreClient::send_abort_txn(const AbortTxnRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("abort_txn", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_abort_txn_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_abort_txn() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("abort_txn") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_abort_txn_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + return; +} + +void ThriftHiveMetastoreClient::abort_txns(const AbortTxnsRequest& rqst) +{ + send_abort_txns(rqst); + recv_abort_txns(); +} + +void ThriftHiveMetastoreClient::send_abort_txns(const AbortTxnsRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("abort_txns", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_abort_txns_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_abort_txns() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("abort_txns") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_abort_txns_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + return; +} + +void ThriftHiveMetastoreClient::commit_txn(const CommitTxnRequest& rqst) +{ + send_commit_txn(rqst); + recv_commit_txn(); +} + +void ThriftHiveMetastoreClient::send_commit_txn(const CommitTxnRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("commit_txn", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_commit_txn_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_commit_txn() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("commit_txn") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_commit_txn_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +int64_t ThriftHiveMetastoreClient::get_latest_txnid_in_conflict(const int64_t txnId) +{ + send_get_latest_txnid_in_conflict(txnId); + return recv_get_latest_txnid_in_conflict(); +} + +void ThriftHiveMetastoreClient::send_get_latest_txnid_in_conflict(const int64_t txnId) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_latest_txnid_in_conflict", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_latest_txnid_in_conflict_pargs args; + args.txnId = &txnId; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +int64_t ThriftHiveMetastoreClient::recv_get_latest_txnid_in_conflict() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_latest_txnid_in_conflict") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + int64_t _return; + ThriftHiveMetastore_get_latest_txnid_in_conflict_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_latest_txnid_in_conflict failed: unknown result"); +} + +void ThriftHiveMetastoreClient::repl_tbl_writeid_state(const ReplTblWriteIdStateRequest& rqst) +{ + send_repl_tbl_writeid_state(rqst); + recv_repl_tbl_writeid_state(); +} + +void ThriftHiveMetastoreClient::send_repl_tbl_writeid_state(const ReplTblWriteIdStateRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("repl_tbl_writeid_state", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_repl_tbl_writeid_state_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_repl_tbl_writeid_state() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("repl_tbl_writeid_state") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_repl_tbl_writeid_state_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + return; +} + +void ThriftHiveMetastoreClient::get_valid_write_ids(GetValidWriteIdsResponse& _return, const GetValidWriteIdsRequest& rqst) +{ + send_get_valid_write_ids(rqst); + recv_get_valid_write_ids(_return); +} + +void ThriftHiveMetastoreClient::send_get_valid_write_ids(const GetValidWriteIdsRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_valid_write_ids", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_valid_write_ids_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_valid_write_ids(GetValidWriteIdsResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_valid_write_ids") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_valid_write_ids_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_valid_write_ids failed: unknown result"); +} + +void ThriftHiveMetastoreClient::add_write_ids_to_min_history(const int64_t txnId, const std::map & writeIds) +{ + send_add_write_ids_to_min_history(txnId, writeIds); + recv_add_write_ids_to_min_history(); +} + +void ThriftHiveMetastoreClient::send_add_write_ids_to_min_history(const int64_t txnId, const std::map & writeIds) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("add_write_ids_to_min_history", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_write_ids_to_min_history_pargs args; + args.txnId = &txnId; + args.writeIds = &writeIds; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_add_write_ids_to_min_history() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_write_ids_to_min_history") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_add_write_ids_to_min_history_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::allocate_table_write_ids(AllocateTableWriteIdsResponse& _return, const AllocateTableWriteIdsRequest& rqst) +{ + send_allocate_table_write_ids(rqst); + recv_allocate_table_write_ids(_return); +} + +void ThriftHiveMetastoreClient::send_allocate_table_write_ids(const AllocateTableWriteIdsRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("allocate_table_write_ids", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_allocate_table_write_ids_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_allocate_table_write_ids(AllocateTableWriteIdsResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("allocate_table_write_ids") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_allocate_table_write_ids_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "allocate_table_write_ids failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_max_allocated_table_write_id(MaxAllocatedTableWriteIdResponse& _return, const MaxAllocatedTableWriteIdRequest& rqst) +{ + send_get_max_allocated_table_write_id(rqst); + recv_get_max_allocated_table_write_id(_return); +} + +void ThriftHiveMetastoreClient::send_get_max_allocated_table_write_id(const MaxAllocatedTableWriteIdRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_max_allocated_table_write_id", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_max_allocated_table_write_id_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_max_allocated_table_write_id(MaxAllocatedTableWriteIdResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_max_allocated_table_write_id") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_max_allocated_table_write_id_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_max_allocated_table_write_id failed: unknown result"); +} + +void ThriftHiveMetastoreClient::seed_write_id(const SeedTableWriteIdsRequest& rqst) +{ + send_seed_write_id(rqst); + recv_seed_write_id(); +} + +void ThriftHiveMetastoreClient::send_seed_write_id(const SeedTableWriteIdsRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("seed_write_id", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_seed_write_id_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_seed_write_id() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("seed_write_id") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_seed_write_id_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + return; +} + +void ThriftHiveMetastoreClient::seed_txn_id(const SeedTxnIdRequest& rqst) +{ + send_seed_txn_id(rqst); + recv_seed_txn_id(); +} + +void ThriftHiveMetastoreClient::send_seed_txn_id(const SeedTxnIdRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("seed_txn_id", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_seed_txn_id_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_seed_txn_id() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("seed_txn_id") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_seed_txn_id_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + return; +} + +void ThriftHiveMetastoreClient::lock(LockResponse& _return, const LockRequest& rqst) +{ + send_lock(rqst); + recv_lock(_return); +} + +void ThriftHiveMetastoreClient::send_lock(const LockRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("lock", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_lock_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_lock(LockResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("lock") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_lock_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "lock failed: unknown result"); +} + +void ThriftHiveMetastoreClient::check_lock(LockResponse& _return, const CheckLockRequest& rqst) +{ + send_check_lock(rqst); + recv_check_lock(_return); +} + +void ThriftHiveMetastoreClient::send_check_lock(const CheckLockRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("check_lock", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_check_lock_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_check_lock(LockResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("check_lock") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_check_lock_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "check_lock failed: unknown result"); +} + +void ThriftHiveMetastoreClient::unlock(const UnlockRequest& rqst) +{ + send_unlock(rqst); + recv_unlock(); +} + +void ThriftHiveMetastoreClient::send_unlock(const UnlockRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("unlock", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_unlock_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_unlock() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("unlock") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_unlock_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::show_locks(ShowLocksResponse& _return, const ShowLocksRequest& rqst) +{ + send_show_locks(rqst); + recv_show_locks(_return); +} + +void ThriftHiveMetastoreClient::send_show_locks(const ShowLocksRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("show_locks", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_show_locks_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_show_locks(ShowLocksResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("show_locks") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_show_locks_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "show_locks failed: unknown result"); +} + +void ThriftHiveMetastoreClient::heartbeat(const HeartbeatRequest& ids) +{ + send_heartbeat(ids); + recv_heartbeat(); +} + +void ThriftHiveMetastoreClient::send_heartbeat(const HeartbeatRequest& ids) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("heartbeat", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_heartbeat_pargs args; + args.ids = &ids; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_heartbeat() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("heartbeat") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_heartbeat_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + return; +} + +void ThriftHiveMetastoreClient::heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const HeartbeatTxnRangeRequest& txns) +{ + send_heartbeat_txn_range(txns); + recv_heartbeat_txn_range(_return); +} + +void ThriftHiveMetastoreClient::send_heartbeat_txn_range(const HeartbeatTxnRangeRequest& txns) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("heartbeat_txn_range", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_heartbeat_txn_range_pargs args; + args.txns = &txns; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_heartbeat_txn_range(HeartbeatTxnRangeResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("heartbeat_txn_range") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_heartbeat_txn_range_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "heartbeat_txn_range failed: unknown result"); +} + +void ThriftHiveMetastoreClient::compact(const CompactionRequest& rqst) +{ + send_compact(rqst); + recv_compact(); +} + +void ThriftHiveMetastoreClient::send_compact(const CompactionRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("compact", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_compact_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_compact() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("compact") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_compact_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + return; +} + +void ThriftHiveMetastoreClient::compact2(CompactionResponse& _return, const CompactionRequest& rqst) +{ + send_compact2(rqst); + recv_compact2(_return); +} + +void ThriftHiveMetastoreClient::send_compact2(const CompactionRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("compact2", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_compact2_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_compact2(CompactionResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("compact2") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_compact2_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "compact2 failed: unknown result"); +} + +void ThriftHiveMetastoreClient::show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst) +{ + send_show_compact(rqst); + recv_show_compact(_return); +} + +void ThriftHiveMetastoreClient::send_show_compact(const ShowCompactRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("show_compact", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_show_compact_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_show_compact(ShowCompactResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("show_compact") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_show_compact_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "show_compact failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::submit_for_cleanup(const CompactionRequest& o1, const int64_t o2, const int64_t o3) +{ + send_submit_for_cleanup(o1, o2, o3); + return recv_submit_for_cleanup(); +} + +void ThriftHiveMetastoreClient::send_submit_for_cleanup(const CompactionRequest& o1, const int64_t o2, const int64_t o3) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("submit_for_cleanup", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_submit_for_cleanup_pargs args; + args.o1 = &o1; + args.o2 = &o2; + args.o3 = &o3; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_submit_for_cleanup() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("submit_for_cleanup") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_submit_for_cleanup_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "submit_for_cleanup failed: unknown result"); +} + +void ThriftHiveMetastoreClient::add_dynamic_partitions(const AddDynamicPartitions& rqst) +{ + send_add_dynamic_partitions(rqst); + recv_add_dynamic_partitions(); +} + +void ThriftHiveMetastoreClient::send_add_dynamic_partitions(const AddDynamicPartitions& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("add_dynamic_partitions", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_dynamic_partitions_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_add_dynamic_partitions() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_dynamic_partitions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_add_dynamic_partitions_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::find_next_compact(OptionalCompactionInfoStruct& _return, const std::string& workerId) +{ + send_find_next_compact(workerId); + recv_find_next_compact(_return); +} + +void ThriftHiveMetastoreClient::send_find_next_compact(const std::string& workerId) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("find_next_compact", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_find_next_compact_pargs args; + args.workerId = &workerId; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_find_next_compact(OptionalCompactionInfoStruct& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("find_next_compact") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_find_next_compact_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "find_next_compact failed: unknown result"); +} + +void ThriftHiveMetastoreClient::find_next_compact2(OptionalCompactionInfoStruct& _return, const FindNextCompactRequest& rqst) +{ + send_find_next_compact2(rqst); + recv_find_next_compact2(_return); +} + +void ThriftHiveMetastoreClient::send_find_next_compact2(const FindNextCompactRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("find_next_compact2", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_find_next_compact2_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_find_next_compact2(OptionalCompactionInfoStruct& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("find_next_compact2") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_find_next_compact2_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "find_next_compact2 failed: unknown result"); +} + +void ThriftHiveMetastoreClient::update_compactor_state(const CompactionInfoStruct& cr, const int64_t txn_id) +{ + send_update_compactor_state(cr, txn_id); + recv_update_compactor_state(); +} + +void ThriftHiveMetastoreClient::send_update_compactor_state(const CompactionInfoStruct& cr, const int64_t txn_id) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("update_compactor_state", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_update_compactor_state_pargs args; + args.cr = &cr; + args.txn_id = &txn_id; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_update_compactor_state() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("update_compactor_state") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_update_compactor_state_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + return; +} + +void ThriftHiveMetastoreClient::find_columns_with_stats(std::vector & _return, const CompactionInfoStruct& cr) +{ + send_find_columns_with_stats(cr); + recv_find_columns_with_stats(_return); +} + +void ThriftHiveMetastoreClient::send_find_columns_with_stats(const CompactionInfoStruct& cr) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("find_columns_with_stats", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_find_columns_with_stats_pargs args; + args.cr = &cr; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_find_columns_with_stats(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("find_columns_with_stats") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_find_columns_with_stats_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "find_columns_with_stats failed: unknown result"); +} + +void ThriftHiveMetastoreClient::mark_cleaned(const CompactionInfoStruct& cr) +{ + send_mark_cleaned(cr); + recv_mark_cleaned(); +} + +void ThriftHiveMetastoreClient::send_mark_cleaned(const CompactionInfoStruct& cr) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("mark_cleaned", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_mark_cleaned_pargs args; + args.cr = &cr; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_mark_cleaned() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("mark_cleaned") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_mark_cleaned_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + return; +} + +void ThriftHiveMetastoreClient::mark_compacted(const CompactionInfoStruct& cr) +{ + send_mark_compacted(cr); + recv_mark_compacted(); +} + +void ThriftHiveMetastoreClient::send_mark_compacted(const CompactionInfoStruct& cr) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("mark_compacted", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_mark_compacted_pargs args; + args.cr = &cr; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_mark_compacted() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("mark_compacted") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_mark_compacted_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + return; +} + +void ThriftHiveMetastoreClient::mark_failed(const CompactionInfoStruct& cr) +{ + send_mark_failed(cr); + recv_mark_failed(); +} + +void ThriftHiveMetastoreClient::send_mark_failed(const CompactionInfoStruct& cr) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("mark_failed", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_mark_failed_pargs args; + args.cr = &cr; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_mark_failed() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("mark_failed") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_mark_failed_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + return; +} + +void ThriftHiveMetastoreClient::mark_refused(const CompactionInfoStruct& cr) +{ + send_mark_refused(cr); + recv_mark_refused(); +} + +void ThriftHiveMetastoreClient::send_mark_refused(const CompactionInfoStruct& cr) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("mark_refused", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_mark_refused_pargs args; + args.cr = &cr; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_mark_refused() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("mark_refused") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_mark_refused_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + return; +} + +bool ThriftHiveMetastoreClient::update_compaction_metrics_data(const CompactionMetricsDataStruct& data) +{ + send_update_compaction_metrics_data(data); + return recv_update_compaction_metrics_data(); +} + +void ThriftHiveMetastoreClient::send_update_compaction_metrics_data(const CompactionMetricsDataStruct& data) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("update_compaction_metrics_data", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_update_compaction_metrics_data_pargs args; + args.data = &data; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_update_compaction_metrics_data() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("update_compaction_metrics_data") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_update_compaction_metrics_data_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "update_compaction_metrics_data failed: unknown result"); +} + +void ThriftHiveMetastoreClient::remove_compaction_metrics_data(const CompactionMetricsDataRequest& request) +{ + send_remove_compaction_metrics_data(request); + recv_remove_compaction_metrics_data(); +} + +void ThriftHiveMetastoreClient::send_remove_compaction_metrics_data(const CompactionMetricsDataRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("remove_compaction_metrics_data", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_remove_compaction_metrics_data_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_remove_compaction_metrics_data() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("remove_compaction_metrics_data") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_remove_compaction_metrics_data_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + return; +} + +void ThriftHiveMetastoreClient::set_hadoop_jobid(const std::string& jobId, const int64_t cq_id) +{ + send_set_hadoop_jobid(jobId, cq_id); + recv_set_hadoop_jobid(); +} + +void ThriftHiveMetastoreClient::send_set_hadoop_jobid(const std::string& jobId, const int64_t cq_id) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("set_hadoop_jobid", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_set_hadoop_jobid_pargs args; + args.jobId = &jobId; + args.cq_id = &cq_id; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_set_hadoop_jobid() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("set_hadoop_jobid") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_set_hadoop_jobid_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + return; +} + +void ThriftHiveMetastoreClient::get_latest_committed_compaction_info(GetLatestCommittedCompactionInfoResponse& _return, const GetLatestCommittedCompactionInfoRequest& rqst) +{ + send_get_latest_committed_compaction_info(rqst); + recv_get_latest_committed_compaction_info(_return); +} + +void ThriftHiveMetastoreClient::send_get_latest_committed_compaction_info(const GetLatestCommittedCompactionInfoRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_latest_committed_compaction_info", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_latest_committed_compaction_info_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_latest_committed_compaction_info(GetLatestCommittedCompactionInfoResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_latest_committed_compaction_info") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_latest_committed_compaction_info_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_latest_committed_compaction_info failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_next_notification(NotificationEventResponse& _return, const NotificationEventRequest& rqst) +{ + send_get_next_notification(rqst); + recv_get_next_notification(_return); +} + +void ThriftHiveMetastoreClient::send_get_next_notification(const NotificationEventRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_next_notification", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_next_notification_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_next_notification(NotificationEventResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_next_notification") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_next_notification_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_next_notification failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_current_notificationEventId(CurrentNotificationEventId& _return) +{ + send_get_current_notificationEventId(); + recv_get_current_notificationEventId(_return); +} + +void ThriftHiveMetastoreClient::send_get_current_notificationEventId() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_current_notificationEventId", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_current_notificationEventId_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_current_notificationEventId(CurrentNotificationEventId& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_current_notificationEventId") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_current_notificationEventId_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_current_notificationEventId failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_notification_events_count(NotificationEventsCountResponse& _return, const NotificationEventsCountRequest& rqst) +{ + send_get_notification_events_count(rqst); + recv_get_notification_events_count(_return); +} + +void ThriftHiveMetastoreClient::send_get_notification_events_count(const NotificationEventsCountRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_notification_events_count", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_notification_events_count_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_notification_events_count(NotificationEventsCountResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_notification_events_count") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_notification_events_count_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_notification_events_count failed: unknown result"); +} + +void ThriftHiveMetastoreClient::fire_listener_event(FireEventResponse& _return, const FireEventRequest& rqst) +{ + send_fire_listener_event(rqst); + recv_fire_listener_event(_return); +} + +void ThriftHiveMetastoreClient::send_fire_listener_event(const FireEventRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("fire_listener_event", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_fire_listener_event_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_fire_listener_event(FireEventResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("fire_listener_event") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_fire_listener_event_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "fire_listener_event failed: unknown result"); +} + +void ThriftHiveMetastoreClient::flushCache() +{ + send_flushCache(); + recv_flushCache(); +} + +void ThriftHiveMetastoreClient::send_flushCache() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("flushCache", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_flushCache_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_flushCache() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("flushCache") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_flushCache_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + return; +} + +void ThriftHiveMetastoreClient::add_write_notification_log(WriteNotificationLogResponse& _return, const WriteNotificationLogRequest& rqst) +{ + send_add_write_notification_log(rqst); + recv_add_write_notification_log(_return); +} + +void ThriftHiveMetastoreClient::send_add_write_notification_log(const WriteNotificationLogRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("add_write_notification_log", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_write_notification_log_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_add_write_notification_log(WriteNotificationLogResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_write_notification_log") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_add_write_notification_log_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "add_write_notification_log failed: unknown result"); +} + +void ThriftHiveMetastoreClient::add_write_notification_log_in_batch(WriteNotificationLogBatchResponse& _return, const WriteNotificationLogBatchRequest& rqst) +{ + send_add_write_notification_log_in_batch(rqst); + recv_add_write_notification_log_in_batch(_return); +} + +void ThriftHiveMetastoreClient::send_add_write_notification_log_in_batch(const WriteNotificationLogBatchRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("add_write_notification_log_in_batch", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_write_notification_log_in_batch_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_add_write_notification_log_in_batch(WriteNotificationLogBatchResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_write_notification_log_in_batch") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_add_write_notification_log_in_batch_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "add_write_notification_log_in_batch failed: unknown result"); +} + +void ThriftHiveMetastoreClient::cm_recycle(CmRecycleResponse& _return, const CmRecycleRequest& request) +{ + send_cm_recycle(request); + recv_cm_recycle(_return); +} + +void ThriftHiveMetastoreClient::send_cm_recycle(const CmRecycleRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("cm_recycle", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_cm_recycle_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_cm_recycle(CmRecycleResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("cm_recycle") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_cm_recycle_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "cm_recycle failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req) +{ + send_get_file_metadata_by_expr(req); + recv_get_file_metadata_by_expr(_return); +} + +void ThriftHiveMetastoreClient::send_get_file_metadata_by_expr(const GetFileMetadataByExprRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_file_metadata_by_expr", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_file_metadata_by_expr_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_file_metadata_by_expr(GetFileMetadataByExprResult& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_file_metadata_by_expr") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_file_metadata_by_expr_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_file_metadata_by_expr failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_file_metadata(GetFileMetadataResult& _return, const GetFileMetadataRequest& req) +{ + send_get_file_metadata(req); + recv_get_file_metadata(_return); +} + +void ThriftHiveMetastoreClient::send_get_file_metadata(const GetFileMetadataRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_file_metadata", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_file_metadata_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_file_metadata(GetFileMetadataResult& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_file_metadata") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_file_metadata_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_file_metadata failed: unknown result"); +} + +void ThriftHiveMetastoreClient::put_file_metadata(PutFileMetadataResult& _return, const PutFileMetadataRequest& req) +{ + send_put_file_metadata(req); + recv_put_file_metadata(_return); +} + +void ThriftHiveMetastoreClient::send_put_file_metadata(const PutFileMetadataRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("put_file_metadata", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_put_file_metadata_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_put_file_metadata(PutFileMetadataResult& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("put_file_metadata") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_put_file_metadata_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "put_file_metadata failed: unknown result"); +} + +void ThriftHiveMetastoreClient::clear_file_metadata(ClearFileMetadataResult& _return, const ClearFileMetadataRequest& req) +{ + send_clear_file_metadata(req); + recv_clear_file_metadata(_return); +} + +void ThriftHiveMetastoreClient::send_clear_file_metadata(const ClearFileMetadataRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("clear_file_metadata", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_clear_file_metadata_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_clear_file_metadata(ClearFileMetadataResult& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("clear_file_metadata") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_clear_file_metadata_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "clear_file_metadata failed: unknown result"); +} + +void ThriftHiveMetastoreClient::cache_file_metadata(CacheFileMetadataResult& _return, const CacheFileMetadataRequest& req) +{ + send_cache_file_metadata(req); + recv_cache_file_metadata(_return); +} + +void ThriftHiveMetastoreClient::send_cache_file_metadata(const CacheFileMetadataRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("cache_file_metadata", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_cache_file_metadata_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_cache_file_metadata(CacheFileMetadataResult& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("cache_file_metadata") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_cache_file_metadata_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "cache_file_metadata failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_metastore_db_uuid(std::string& _return) +{ + send_get_metastore_db_uuid(); + recv_get_metastore_db_uuid(_return); +} + +void ThriftHiveMetastoreClient::send_get_metastore_db_uuid() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_metastore_db_uuid", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_metastore_db_uuid_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_metastore_db_uuid(std::string& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_metastore_db_uuid") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_metastore_db_uuid_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_metastore_db_uuid failed: unknown result"); +} + +void ThriftHiveMetastoreClient::create_resource_plan(WMCreateResourcePlanResponse& _return, const WMCreateResourcePlanRequest& request) +{ + send_create_resource_plan(request); + recv_create_resource_plan(_return); +} + +void ThriftHiveMetastoreClient::send_create_resource_plan(const WMCreateResourcePlanRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("create_resource_plan", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_resource_plan_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_create_resource_plan(WMCreateResourcePlanResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_resource_plan") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_create_resource_plan_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "create_resource_plan failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_resource_plan(WMGetResourcePlanResponse& _return, const WMGetResourcePlanRequest& request) +{ + send_get_resource_plan(request); + recv_get_resource_plan(_return); +} + +void ThriftHiveMetastoreClient::send_get_resource_plan(const WMGetResourcePlanRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_resource_plan", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_resource_plan_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_resource_plan(WMGetResourcePlanResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_resource_plan") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_resource_plan_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_resource_plan failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_active_resource_plan(WMGetActiveResourcePlanResponse& _return, const WMGetActiveResourcePlanRequest& request) +{ + send_get_active_resource_plan(request); + recv_get_active_resource_plan(_return); +} + +void ThriftHiveMetastoreClient::send_get_active_resource_plan(const WMGetActiveResourcePlanRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_active_resource_plan", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_active_resource_plan_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_active_resource_plan(WMGetActiveResourcePlanResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_active_resource_plan") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_active_resource_plan_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_active_resource_plan failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_all_resource_plans(WMGetAllResourcePlanResponse& _return, const WMGetAllResourcePlanRequest& request) +{ + send_get_all_resource_plans(request); + recv_get_all_resource_plans(_return); +} + +void ThriftHiveMetastoreClient::send_get_all_resource_plans(const WMGetAllResourcePlanRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_all_resource_plans", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_all_resource_plans_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_all_resource_plans(WMGetAllResourcePlanResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_all_resource_plans") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_all_resource_plans_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_resource_plans failed: unknown result"); +} + +void ThriftHiveMetastoreClient::alter_resource_plan(WMAlterResourcePlanResponse& _return, const WMAlterResourcePlanRequest& request) +{ + send_alter_resource_plan(request); + recv_alter_resource_plan(_return); +} + +void ThriftHiveMetastoreClient::send_alter_resource_plan(const WMAlterResourcePlanRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("alter_resource_plan", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_resource_plan_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_alter_resource_plan(WMAlterResourcePlanResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_resource_plan") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_alter_resource_plan_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "alter_resource_plan failed: unknown result"); +} + +void ThriftHiveMetastoreClient::validate_resource_plan(WMValidateResourcePlanResponse& _return, const WMValidateResourcePlanRequest& request) +{ + send_validate_resource_plan(request); + recv_validate_resource_plan(_return); +} + +void ThriftHiveMetastoreClient::send_validate_resource_plan(const WMValidateResourcePlanRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("validate_resource_plan", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_validate_resource_plan_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_validate_resource_plan(WMValidateResourcePlanResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("validate_resource_plan") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_validate_resource_plan_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "validate_resource_plan failed: unknown result"); +} + +void ThriftHiveMetastoreClient::drop_resource_plan(WMDropResourcePlanResponse& _return, const WMDropResourcePlanRequest& request) +{ + send_drop_resource_plan(request); + recv_drop_resource_plan(_return); +} + +void ThriftHiveMetastoreClient::send_drop_resource_plan(const WMDropResourcePlanRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_resource_plan", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_resource_plan_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_drop_resource_plan(WMDropResourcePlanResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_resource_plan") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_drop_resource_plan_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_resource_plan failed: unknown result"); +} + +void ThriftHiveMetastoreClient::create_wm_trigger(WMCreateTriggerResponse& _return, const WMCreateTriggerRequest& request) +{ + send_create_wm_trigger(request); + recv_create_wm_trigger(_return); +} + +void ThriftHiveMetastoreClient::send_create_wm_trigger(const WMCreateTriggerRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("create_wm_trigger", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_wm_trigger_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_create_wm_trigger(WMCreateTriggerResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_wm_trigger") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_create_wm_trigger_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "create_wm_trigger failed: unknown result"); +} + +void ThriftHiveMetastoreClient::alter_wm_trigger(WMAlterTriggerResponse& _return, const WMAlterTriggerRequest& request) +{ + send_alter_wm_trigger(request); + recv_alter_wm_trigger(_return); +} + +void ThriftHiveMetastoreClient::send_alter_wm_trigger(const WMAlterTriggerRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("alter_wm_trigger", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_wm_trigger_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_alter_wm_trigger(WMAlterTriggerResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_wm_trigger") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_alter_wm_trigger_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "alter_wm_trigger failed: unknown result"); +} + +void ThriftHiveMetastoreClient::drop_wm_trigger(WMDropTriggerResponse& _return, const WMDropTriggerRequest& request) +{ + send_drop_wm_trigger(request); + recv_drop_wm_trigger(_return); +} + +void ThriftHiveMetastoreClient::send_drop_wm_trigger(const WMDropTriggerRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_wm_trigger", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_wm_trigger_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_drop_wm_trigger(WMDropTriggerResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_wm_trigger") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_drop_wm_trigger_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_wm_trigger failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const WMGetTriggersForResourePlanRequest& request) +{ + send_get_triggers_for_resourceplan(request); + recv_get_triggers_for_resourceplan(_return); +} + +void ThriftHiveMetastoreClient::send_get_triggers_for_resourceplan(const WMGetTriggersForResourePlanRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_triggers_for_resourceplan", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_triggers_for_resourceplan_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_triggers_for_resourceplan") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_triggers_for_resourceplan_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_triggers_for_resourceplan failed: unknown result"); +} + +void ThriftHiveMetastoreClient::create_wm_pool(WMCreatePoolResponse& _return, const WMCreatePoolRequest& request) +{ + send_create_wm_pool(request); + recv_create_wm_pool(_return); +} + +void ThriftHiveMetastoreClient::send_create_wm_pool(const WMCreatePoolRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("create_wm_pool", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_wm_pool_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_create_wm_pool(WMCreatePoolResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_wm_pool") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_create_wm_pool_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "create_wm_pool failed: unknown result"); +} + +void ThriftHiveMetastoreClient::alter_wm_pool(WMAlterPoolResponse& _return, const WMAlterPoolRequest& request) +{ + send_alter_wm_pool(request); + recv_alter_wm_pool(_return); +} + +void ThriftHiveMetastoreClient::send_alter_wm_pool(const WMAlterPoolRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("alter_wm_pool", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_wm_pool_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_alter_wm_pool(WMAlterPoolResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_wm_pool") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_alter_wm_pool_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "alter_wm_pool failed: unknown result"); +} + +void ThriftHiveMetastoreClient::drop_wm_pool(WMDropPoolResponse& _return, const WMDropPoolRequest& request) +{ + send_drop_wm_pool(request); + recv_drop_wm_pool(_return); +} + +void ThriftHiveMetastoreClient::send_drop_wm_pool(const WMDropPoolRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_wm_pool", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_wm_pool_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_drop_wm_pool(WMDropPoolResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_wm_pool") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_drop_wm_pool_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_wm_pool failed: unknown result"); +} + +void ThriftHiveMetastoreClient::create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const WMCreateOrUpdateMappingRequest& request) +{ + send_create_or_update_wm_mapping(request); + recv_create_or_update_wm_mapping(_return); +} + +void ThriftHiveMetastoreClient::send_create_or_update_wm_mapping(const WMCreateOrUpdateMappingRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("create_or_update_wm_mapping", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_or_update_wm_mapping_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_or_update_wm_mapping") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_create_or_update_wm_mapping_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "create_or_update_wm_mapping failed: unknown result"); +} + +void ThriftHiveMetastoreClient::drop_wm_mapping(WMDropMappingResponse& _return, const WMDropMappingRequest& request) +{ + send_drop_wm_mapping(request); + recv_drop_wm_mapping(_return); +} + +void ThriftHiveMetastoreClient::send_drop_wm_mapping(const WMDropMappingRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_wm_mapping", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_wm_mapping_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_drop_wm_mapping(WMDropMappingResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_wm_mapping") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_drop_wm_mapping_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_wm_mapping failed: unknown result"); +} + +void ThriftHiveMetastoreClient::create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return, const WMCreateOrDropTriggerToPoolMappingRequest& request) +{ + send_create_or_drop_wm_trigger_to_pool_mapping(request); + recv_create_or_drop_wm_trigger_to_pool_mapping(_return); +} + +void ThriftHiveMetastoreClient::send_create_or_drop_wm_trigger_to_pool_mapping(const WMCreateOrDropTriggerToPoolMappingRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("create_or_drop_wm_trigger_to_pool_mapping", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_or_drop_wm_trigger_to_pool_mapping") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "create_or_drop_wm_trigger_to_pool_mapping failed: unknown result"); +} + +void ThriftHiveMetastoreClient::create_ischema(const ISchema& schema) +{ + send_create_ischema(schema); + recv_create_ischema(); +} + +void ThriftHiveMetastoreClient::send_create_ischema(const ISchema& schema) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("create_ischema", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_ischema_pargs args; + args.schema = &schema; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_create_ischema() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_ischema") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_create_ischema_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + return; +} + +void ThriftHiveMetastoreClient::alter_ischema(const AlterISchemaRequest& rqst) +{ + send_alter_ischema(rqst); + recv_alter_ischema(); +} + +void ThriftHiveMetastoreClient::send_alter_ischema(const AlterISchemaRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("alter_ischema", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_ischema_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_alter_ischema() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_ischema") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_alter_ischema_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::get_ischema(ISchema& _return, const ISchemaName& name) +{ + send_get_ischema(name); + recv_get_ischema(_return); +} + +void ThriftHiveMetastoreClient::send_get_ischema(const ISchemaName& name) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_ischema", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_ischema_pargs args; + args.name = &name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_ischema(ISchema& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_ischema") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_ischema_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_ischema failed: unknown result"); +} + +void ThriftHiveMetastoreClient::drop_ischema(const ISchemaName& name) +{ + send_drop_ischema(name); + recv_drop_ischema(); +} + +void ThriftHiveMetastoreClient::send_drop_ischema(const ISchemaName& name) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_ischema", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_ischema_pargs args; + args.name = &name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_drop_ischema() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_ischema") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_drop_ischema_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + return; +} + +void ThriftHiveMetastoreClient::add_schema_version(const SchemaVersion& schemaVersion) +{ + send_add_schema_version(schemaVersion); + recv_add_schema_version(); +} + +void ThriftHiveMetastoreClient::send_add_schema_version(const SchemaVersion& schemaVersion) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("add_schema_version", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_schema_version_pargs args; + args.schemaVersion = &schemaVersion; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_add_schema_version() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_schema_version") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_add_schema_version_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + return; +} + +void ThriftHiveMetastoreClient::get_schema_version(SchemaVersion& _return, const SchemaVersionDescriptor& schemaVersion) +{ + send_get_schema_version(schemaVersion); + recv_get_schema_version(_return); +} + +void ThriftHiveMetastoreClient::send_get_schema_version(const SchemaVersionDescriptor& schemaVersion) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_schema_version", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_schema_version_pargs args; + args.schemaVersion = &schemaVersion; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_schema_version(SchemaVersion& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_schema_version") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_schema_version_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_schema_version failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_schema_latest_version(SchemaVersion& _return, const ISchemaName& schemaName) +{ + send_get_schema_latest_version(schemaName); + recv_get_schema_latest_version(_return); +} + +void ThriftHiveMetastoreClient::send_get_schema_latest_version(const ISchemaName& schemaName) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_schema_latest_version", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_schema_latest_version_pargs args; + args.schemaName = &schemaName; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_schema_latest_version(SchemaVersion& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_schema_latest_version") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_schema_latest_version_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_schema_latest_version failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_schema_all_versions(std::vector & _return, const ISchemaName& schemaName) +{ + send_get_schema_all_versions(schemaName); + recv_get_schema_all_versions(_return); +} + +void ThriftHiveMetastoreClient::send_get_schema_all_versions(const ISchemaName& schemaName) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_schema_all_versions", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_schema_all_versions_pargs args; + args.schemaName = &schemaName; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_schema_all_versions(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_schema_all_versions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_schema_all_versions_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_schema_all_versions failed: unknown result"); +} + +void ThriftHiveMetastoreClient::drop_schema_version(const SchemaVersionDescriptor& schemaVersion) +{ + send_drop_schema_version(schemaVersion); + recv_drop_schema_version(); +} + +void ThriftHiveMetastoreClient::send_drop_schema_version(const SchemaVersionDescriptor& schemaVersion) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_schema_version", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_schema_version_pargs args; + args.schemaVersion = &schemaVersion; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_drop_schema_version() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_schema_version") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_drop_schema_version_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::get_schemas_by_cols(FindSchemasByColsResp& _return, const FindSchemasByColsRqst& rqst) +{ + send_get_schemas_by_cols(rqst); + recv_get_schemas_by_cols(_return); +} + +void ThriftHiveMetastoreClient::send_get_schemas_by_cols(const FindSchemasByColsRqst& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_schemas_by_cols", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_schemas_by_cols_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_schemas_by_cols(FindSchemasByColsResp& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_schemas_by_cols") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_schemas_by_cols_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_schemas_by_cols failed: unknown result"); +} + +void ThriftHiveMetastoreClient::map_schema_version_to_serde(const MapSchemaVersionToSerdeRequest& rqst) +{ + send_map_schema_version_to_serde(rqst); + recv_map_schema_version_to_serde(); +} + +void ThriftHiveMetastoreClient::send_map_schema_version_to_serde(const MapSchemaVersionToSerdeRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("map_schema_version_to_serde", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_map_schema_version_to_serde_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_map_schema_version_to_serde() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("map_schema_version_to_serde") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_map_schema_version_to_serde_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::set_schema_version_state(const SetSchemaVersionStateRequest& rqst) +{ + send_set_schema_version_state(rqst); + recv_set_schema_version_state(); +} + +void ThriftHiveMetastoreClient::send_set_schema_version_state(const SetSchemaVersionStateRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("set_schema_version_state", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_set_schema_version_state_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_set_schema_version_state() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("set_schema_version_state") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_set_schema_version_state_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + return; +} + +void ThriftHiveMetastoreClient::add_serde(const SerDeInfo& serde) +{ + send_add_serde(serde); + recv_add_serde(); +} + +void ThriftHiveMetastoreClient::send_add_serde(const SerDeInfo& serde) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("add_serde", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_serde_pargs args; + args.serde = &serde; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_add_serde() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_serde") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_add_serde_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::get_serde(SerDeInfo& _return, const GetSerdeRequest& rqst) +{ + send_get_serde(rqst); + recv_get_serde(_return); +} + +void ThriftHiveMetastoreClient::send_get_serde(const GetSerdeRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_serde", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_serde_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_serde(SerDeInfo& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_serde") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_serde_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_serde failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_lock_materialization_rebuild(LockResponse& _return, const std::string& dbName, const std::string& tableName, const int64_t txnId) +{ + send_get_lock_materialization_rebuild(dbName, tableName, txnId); + recv_get_lock_materialization_rebuild(_return); +} + +void ThriftHiveMetastoreClient::send_get_lock_materialization_rebuild(const std::string& dbName, const std::string& tableName, const int64_t txnId) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_lock_materialization_rebuild", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_lock_materialization_rebuild_pargs args; + args.dbName = &dbName; + args.tableName = &tableName; + args.txnId = &txnId; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_lock_materialization_rebuild(LockResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_lock_materialization_rebuild") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_lock_materialization_rebuild_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_lock_materialization_rebuild failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::heartbeat_lock_materialization_rebuild(const std::string& dbName, const std::string& tableName, const int64_t txnId) +{ + send_heartbeat_lock_materialization_rebuild(dbName, tableName, txnId); + return recv_heartbeat_lock_materialization_rebuild(); +} + +void ThriftHiveMetastoreClient::send_heartbeat_lock_materialization_rebuild(const std::string& dbName, const std::string& tableName, const int64_t txnId) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("heartbeat_lock_materialization_rebuild", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_pargs args; + args.dbName = &dbName; + args.tableName = &tableName; + args.txnId = &txnId; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_heartbeat_lock_materialization_rebuild() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("heartbeat_lock_materialization_rebuild") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "heartbeat_lock_materialization_rebuild failed: unknown result"); +} + +void ThriftHiveMetastoreClient::add_runtime_stats(const RuntimeStat& stat) +{ + send_add_runtime_stats(stat); + recv_add_runtime_stats(); +} + +void ThriftHiveMetastoreClient::send_add_runtime_stats(const RuntimeStat& stat) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("add_runtime_stats", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_runtime_stats_pargs args; + args.stat = &stat; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_add_runtime_stats() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_runtime_stats") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_add_runtime_stats_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + return; +} + +void ThriftHiveMetastoreClient::get_runtime_stats(std::vector & _return, const GetRuntimeStatsRequest& rqst) +{ + send_get_runtime_stats(rqst); + recv_get_runtime_stats(_return); +} + +void ThriftHiveMetastoreClient::send_get_runtime_stats(const GetRuntimeStatsRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_runtime_stats", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_runtime_stats_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_runtime_stats(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_runtime_stats") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_runtime_stats_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_runtime_stats failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_partitions_with_specs(GetPartitionsResponse& _return, const GetPartitionsRequest& request) +{ + send_get_partitions_with_specs(request); + recv_get_partitions_with_specs(_return); +} + +void ThriftHiveMetastoreClient::send_get_partitions_with_specs(const GetPartitionsRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_partitions_with_specs", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_with_specs_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_partitions_with_specs(GetPartitionsResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_with_specs") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_partitions_with_specs_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_with_specs failed: unknown result"); +} + +void ThriftHiveMetastoreClient::scheduled_query_poll(ScheduledQueryPollResponse& _return, const ScheduledQueryPollRequest& request) +{ + send_scheduled_query_poll(request); + recv_scheduled_query_poll(_return); +} + +void ThriftHiveMetastoreClient::send_scheduled_query_poll(const ScheduledQueryPollRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("scheduled_query_poll", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_scheduled_query_poll_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_scheduled_query_poll(ScheduledQueryPollResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("scheduled_query_poll") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_scheduled_query_poll_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scheduled_query_poll failed: unknown result"); +} + +void ThriftHiveMetastoreClient::scheduled_query_maintenance(const ScheduledQueryMaintenanceRequest& request) +{ + send_scheduled_query_maintenance(request); + recv_scheduled_query_maintenance(); +} + +void ThriftHiveMetastoreClient::send_scheduled_query_maintenance(const ScheduledQueryMaintenanceRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("scheduled_query_maintenance", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_scheduled_query_maintenance_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_scheduled_query_maintenance() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("scheduled_query_maintenance") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_scheduled_query_maintenance_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + return; +} + +void ThriftHiveMetastoreClient::scheduled_query_progress(const ScheduledQueryProgressInfo& info) +{ + send_scheduled_query_progress(info); + recv_scheduled_query_progress(); +} + +void ThriftHiveMetastoreClient::send_scheduled_query_progress(const ScheduledQueryProgressInfo& info) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("scheduled_query_progress", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_scheduled_query_progress_pargs args; + args.info = &info; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_scheduled_query_progress() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("scheduled_query_progress") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_scheduled_query_progress_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::get_scheduled_query(ScheduledQuery& _return, const ScheduledQueryKey& scheduleKey) +{ + send_get_scheduled_query(scheduleKey); + recv_get_scheduled_query(_return); +} + +void ThriftHiveMetastoreClient::send_get_scheduled_query(const ScheduledQueryKey& scheduleKey) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_scheduled_query", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_scheduled_query_pargs args; + args.scheduleKey = &scheduleKey; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_scheduled_query(ScheduledQuery& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_scheduled_query") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_scheduled_query_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_scheduled_query failed: unknown result"); +} + +void ThriftHiveMetastoreClient::add_replication_metrics(const ReplicationMetricList& replicationMetricList) +{ + send_add_replication_metrics(replicationMetricList); + recv_add_replication_metrics(); +} + +void ThriftHiveMetastoreClient::send_add_replication_metrics(const ReplicationMetricList& replicationMetricList) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("add_replication_metrics", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_replication_metrics_pargs args; + args.replicationMetricList = &replicationMetricList; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_add_replication_metrics() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_replication_metrics") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_add_replication_metrics_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + return; +} + +void ThriftHiveMetastoreClient::get_replication_metrics(ReplicationMetricList& _return, const GetReplicationMetricsRequest& rqst) +{ + send_get_replication_metrics(rqst); + recv_get_replication_metrics(_return); +} + +void ThriftHiveMetastoreClient::send_get_replication_metrics(const GetReplicationMetricsRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_replication_metrics", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_replication_metrics_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_replication_metrics(ReplicationMetricList& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_replication_metrics") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_replication_metrics_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_replication_metrics failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_open_txns_req(GetOpenTxnsResponse& _return, const GetOpenTxnsRequest& getOpenTxnsRequest) +{ + send_get_open_txns_req(getOpenTxnsRequest); + recv_get_open_txns_req(_return); +} + +void ThriftHiveMetastoreClient::send_get_open_txns_req(const GetOpenTxnsRequest& getOpenTxnsRequest) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_open_txns_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_open_txns_req_pargs args; + args.getOpenTxnsRequest = &getOpenTxnsRequest; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_open_txns_req(GetOpenTxnsResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_open_txns_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_open_txns_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_open_txns_req failed: unknown result"); +} + +void ThriftHiveMetastoreClient::create_stored_procedure(const StoredProcedure& proc) +{ + send_create_stored_procedure(proc); + recv_create_stored_procedure(); +} + +void ThriftHiveMetastoreClient::send_create_stored_procedure(const StoredProcedure& proc) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("create_stored_procedure", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_stored_procedure_pargs args; + args.proc = &proc; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_create_stored_procedure() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_stored_procedure") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_create_stored_procedure_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + return; +} + +void ThriftHiveMetastoreClient::get_stored_procedure(StoredProcedure& _return, const StoredProcedureRequest& request) +{ + send_get_stored_procedure(request); + recv_get_stored_procedure(_return); +} + +void ThriftHiveMetastoreClient::send_get_stored_procedure(const StoredProcedureRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_stored_procedure", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_stored_procedure_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_stored_procedure(StoredProcedure& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_stored_procedure") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_stored_procedure_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_stored_procedure failed: unknown result"); +} + +void ThriftHiveMetastoreClient::drop_stored_procedure(const StoredProcedureRequest& request) +{ + send_drop_stored_procedure(request); + recv_drop_stored_procedure(); +} + +void ThriftHiveMetastoreClient::send_drop_stored_procedure(const StoredProcedureRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_stored_procedure", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_stored_procedure_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_drop_stored_procedure() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_stored_procedure") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_drop_stored_procedure_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + return; +} + +void ThriftHiveMetastoreClient::get_all_stored_procedures(std::vector & _return, const ListStoredProcedureRequest& request) +{ + send_get_all_stored_procedures(request); + recv_get_all_stored_procedures(_return); +} + +void ThriftHiveMetastoreClient::send_get_all_stored_procedures(const ListStoredProcedureRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_all_stored_procedures", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_all_stored_procedures_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_all_stored_procedures(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_all_stored_procedures") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_all_stored_procedures_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_stored_procedures failed: unknown result"); +} + +void ThriftHiveMetastoreClient::find_package(Package& _return, const GetPackageRequest& request) +{ + send_find_package(request); + recv_find_package(_return); +} + +void ThriftHiveMetastoreClient::send_find_package(const GetPackageRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("find_package", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_find_package_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_find_package(Package& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("find_package") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_find_package_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "find_package failed: unknown result"); +} + +void ThriftHiveMetastoreClient::add_package(const AddPackageRequest& request) +{ + send_add_package(request); + recv_add_package(); +} + +void ThriftHiveMetastoreClient::send_add_package(const AddPackageRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("add_package", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_package_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_add_package() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_package") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_add_package_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + return; +} + +void ThriftHiveMetastoreClient::get_all_packages(std::vector & _return, const ListPackageRequest& request) +{ + send_get_all_packages(request); + recv_get_all_packages(_return); +} + +void ThriftHiveMetastoreClient::send_get_all_packages(const ListPackageRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_all_packages", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_all_packages_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_all_packages(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_all_packages") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_all_packages_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_packages failed: unknown result"); +} + +void ThriftHiveMetastoreClient::drop_package(const DropPackageRequest& request) +{ + send_drop_package(request); + recv_drop_package(); +} + +void ThriftHiveMetastoreClient::send_drop_package(const DropPackageRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_package", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_package_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_drop_package() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_package") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_drop_package_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + return; +} + +void ThriftHiveMetastoreClient::get_all_write_event_info(std::vector & _return, const GetAllWriteEventInfoRequest& request) +{ + send_get_all_write_event_info(request); + recv_get_all_write_event_info(_return); +} + +void ThriftHiveMetastoreClient::send_get_all_write_event_info(const GetAllWriteEventInfoRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_all_write_event_info", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_all_write_event_info_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_all_write_event_info(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_all_write_event_info") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_all_write_event_info_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_write_event_info failed: unknown result"); +} + +bool ThriftHiveMetastoreProcessor::dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext) { + ProcessMap::iterator pfn; + pfn = processMap_.find(fname); + if (pfn == processMap_.end()) { + return ::facebook::fb303::FacebookServiceProcessor::dispatchCall(iprot, oprot, fname, seqid, callContext); + } + (this->*(pfn->second))(seqid, iprot, oprot, callContext); + return true; +} + +void ThriftHiveMetastoreProcessor::process_abort_Compactions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.abort_Compactions", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.abort_Compactions"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.abort_Compactions"); + } + + ThriftHiveMetastore_abort_Compactions_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.abort_Compactions", bytes); + } + + ThriftHiveMetastore_abort_Compactions_result result; + try { + iface_->abort_Compactions(result.success, args.rqst); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.abort_Compactions"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("abort_Compactions", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.abort_Compactions"); + } + + oprot->writeMessageBegin("abort_Compactions", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.abort_Compactions", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_getMetaConf(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.getMetaConf", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.getMetaConf"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.getMetaConf"); + } + + ThriftHiveMetastore_getMetaConf_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.getMetaConf", bytes); + } + + ThriftHiveMetastore_getMetaConf_result result; + try { + iface_->getMetaConf(result.success, args.key); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.getMetaConf"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("getMetaConf", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.getMetaConf"); + } + + oprot->writeMessageBegin("getMetaConf", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.getMetaConf", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_setMetaConf(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.setMetaConf", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.setMetaConf"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.setMetaConf"); + } + + ThriftHiveMetastore_setMetaConf_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.setMetaConf", bytes); + } + + ThriftHiveMetastore_setMetaConf_result result; + try { + iface_->setMetaConf(args.key, args.value); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.setMetaConf"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("setMetaConf", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.setMetaConf"); + } + + oprot->writeMessageBegin("setMetaConf", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.setMetaConf", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_create_catalog(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.create_catalog", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.create_catalog"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.create_catalog"); + } + + ThriftHiveMetastore_create_catalog_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.create_catalog", bytes); + } + + ThriftHiveMetastore_create_catalog_result result; + try { + iface_->create_catalog(args.catalog); + } catch (AlreadyExistsException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.create_catalog"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("create_catalog", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.create_catalog"); + } + + oprot->writeMessageBegin("create_catalog", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.create_catalog", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_alter_catalog(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.alter_catalog", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.alter_catalog"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.alter_catalog"); + } + + ThriftHiveMetastore_alter_catalog_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.alter_catalog", bytes); + } + + ThriftHiveMetastore_alter_catalog_result result; + try { + iface_->alter_catalog(args.rqst); + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidOperationException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.alter_catalog"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("alter_catalog", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.alter_catalog"); + } + + oprot->writeMessageBegin("alter_catalog", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.alter_catalog", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_catalog(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_catalog", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_catalog"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_catalog"); + } + + ThriftHiveMetastore_get_catalog_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_catalog", bytes); + } + + ThriftHiveMetastore_get_catalog_result result; + try { + iface_->get_catalog(result.success, args.catName); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_catalog"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_catalog", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_catalog"); + } + + oprot->writeMessageBegin("get_catalog", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_catalog", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_catalogs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_catalogs", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_catalogs"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_catalogs"); + } + + ThriftHiveMetastore_get_catalogs_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_catalogs", bytes); + } + + ThriftHiveMetastore_get_catalogs_result result; + try { + iface_->get_catalogs(result.success); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_catalogs"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_catalogs", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_catalogs"); + } + + oprot->writeMessageBegin("get_catalogs", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_catalogs", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_catalog(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_catalog", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_catalog"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_catalog"); + } + + ThriftHiveMetastore_drop_catalog_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_catalog", bytes); + } + + ThriftHiveMetastore_drop_catalog_result result; + try { + iface_->drop_catalog(args.catName); + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidOperationException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_catalog"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_catalog", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_catalog"); + } + + oprot->writeMessageBegin("drop_catalog", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_catalog", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_create_database(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.create_database", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.create_database"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.create_database"); + } + + ThriftHiveMetastore_create_database_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.create_database", bytes); + } + + ThriftHiveMetastore_create_database_result result; + try { + iface_->create_database(args.database); + } catch (AlreadyExistsException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.create_database"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("create_database", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.create_database"); + } + + oprot->writeMessageBegin("create_database", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.create_database", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_create_database_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.create_database_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.create_database_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.create_database_req"); + } + + ThriftHiveMetastore_create_database_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.create_database_req", bytes); + } + + ThriftHiveMetastore_create_database_req_result result; + try { + iface_->create_database_req(args.createDatabaseRequest); + } catch (AlreadyExistsException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.create_database_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("create_database_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.create_database_req"); + } + + oprot->writeMessageBegin("create_database_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.create_database_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_database(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_database", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_database"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_database"); + } + + ThriftHiveMetastore_get_database_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_database", bytes); + } + + ThriftHiveMetastore_get_database_result result; + try { + iface_->get_database(result.success, args.name); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_database"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_database", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_database"); + } + + oprot->writeMessageBegin("get_database", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_database", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_database_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_database_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_database_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_database_req"); + } + + ThriftHiveMetastore_get_database_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_database_req", bytes); + } + + ThriftHiveMetastore_get_database_req_result result; + try { + iface_->get_database_req(result.success, args.request); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_database_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_database_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_database_req"); + } + + oprot->writeMessageBegin("get_database_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_database_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_database(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_database", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_database"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_database"); + } + + ThriftHiveMetastore_drop_database_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_database", bytes); + } + + ThriftHiveMetastore_drop_database_result result; + try { + iface_->drop_database(args.name, args.deleteData, args.cascade); + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidOperationException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_database"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_database", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_database"); + } + + oprot->writeMessageBegin("drop_database", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_database", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_database_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_database_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_database_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_database_req"); + } + + ThriftHiveMetastore_drop_database_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_database_req", bytes); + } + + ThriftHiveMetastore_drop_database_req_result result; + try { + iface_->drop_database_req(args.req); + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidOperationException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_database_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_database_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_database_req"); + } + + oprot->writeMessageBegin("drop_database_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_database_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_databases(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_databases", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_databases"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_databases"); + } + + ThriftHiveMetastore_get_databases_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_databases", bytes); + } + + ThriftHiveMetastore_get_databases_result result; + try { + iface_->get_databases(result.success, args.pattern); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_databases"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_databases", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_databases"); + } + + oprot->writeMessageBegin("get_databases", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_databases", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_all_databases(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_all_databases", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_all_databases"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_all_databases"); + } + + ThriftHiveMetastore_get_all_databases_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_all_databases", bytes); + } + + ThriftHiveMetastore_get_all_databases_result result; + try { + iface_->get_all_databases(result.success); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_all_databases"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_all_databases", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_all_databases"); + } + + oprot->writeMessageBegin("get_all_databases", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_all_databases", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_alter_database(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.alter_database", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.alter_database"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.alter_database"); + } + + ThriftHiveMetastore_alter_database_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.alter_database", bytes); + } + + ThriftHiveMetastore_alter_database_result result; + try { + iface_->alter_database(args.dbname, args.db); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.alter_database"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("alter_database", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.alter_database"); + } + + oprot->writeMessageBegin("alter_database", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.alter_database", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_alter_database_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.alter_database_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.alter_database_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.alter_database_req"); + } + + ThriftHiveMetastore_alter_database_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.alter_database_req", bytes); + } + + ThriftHiveMetastore_alter_database_req_result result; + try { + iface_->alter_database_req(args.alterDbReq); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.alter_database_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("alter_database_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.alter_database_req"); + } + + oprot->writeMessageBegin("alter_database_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.alter_database_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_create_dataconnector_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.create_dataconnector_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.create_dataconnector_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.create_dataconnector_req"); + } + + ThriftHiveMetastore_create_dataconnector_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.create_dataconnector_req", bytes); + } + + ThriftHiveMetastore_create_dataconnector_req_result result; + try { + iface_->create_dataconnector_req(args.connectorReq); + } catch (AlreadyExistsException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.create_dataconnector_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("create_dataconnector_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.create_dataconnector_req"); + } + + oprot->writeMessageBegin("create_dataconnector_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.create_dataconnector_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_dataconnector_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_dataconnector_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_dataconnector_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_dataconnector_req"); + } + + ThriftHiveMetastore_get_dataconnector_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_dataconnector_req", bytes); + } + + ThriftHiveMetastore_get_dataconnector_req_result result; + try { + iface_->get_dataconnector_req(result.success, args.request); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_dataconnector_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_dataconnector_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_dataconnector_req"); + } + + oprot->writeMessageBegin("get_dataconnector_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_dataconnector_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_dataconnector_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_dataconnector_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_dataconnector_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_dataconnector_req"); + } + + ThriftHiveMetastore_drop_dataconnector_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_dataconnector_req", bytes); + } + + ThriftHiveMetastore_drop_dataconnector_req_result result; + try { + iface_->drop_dataconnector_req(args.dropDcReq); + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidOperationException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_dataconnector_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_dataconnector_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_dataconnector_req"); + } + + oprot->writeMessageBegin("drop_dataconnector_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_dataconnector_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_dataconnectors(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_dataconnectors", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_dataconnectors"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_dataconnectors"); + } + + ThriftHiveMetastore_get_dataconnectors_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_dataconnectors", bytes); + } + + ThriftHiveMetastore_get_dataconnectors_result result; + try { + iface_->get_dataconnectors(result.success); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_dataconnectors"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_dataconnectors", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_dataconnectors"); + } + + oprot->writeMessageBegin("get_dataconnectors", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_dataconnectors", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_alter_dataconnector_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.alter_dataconnector_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.alter_dataconnector_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.alter_dataconnector_req"); + } + + ThriftHiveMetastore_alter_dataconnector_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.alter_dataconnector_req", bytes); + } + + ThriftHiveMetastore_alter_dataconnector_req_result result; + try { + iface_->alter_dataconnector_req(args.alterReq); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.alter_dataconnector_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("alter_dataconnector_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.alter_dataconnector_req"); + } + + oprot->writeMessageBegin("alter_dataconnector_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.alter_dataconnector_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_type(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_type", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_type"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_type"); + } + + ThriftHiveMetastore_get_type_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_type", bytes); + } + + ThriftHiveMetastore_get_type_result result; + try { + iface_->get_type(result.success, args.name); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_type"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_type", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_type"); + } + + oprot->writeMessageBegin("get_type", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_type", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_create_type(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.create_type", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.create_type"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.create_type"); + } + + ThriftHiveMetastore_create_type_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.create_type", bytes); + } + + ThriftHiveMetastore_create_type_result result; + try { + result.success = iface_->create_type(args.type); + result.__isset.success = true; + } catch (AlreadyExistsException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.create_type"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("create_type", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.create_type"); + } + + oprot->writeMessageBegin("create_type", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.create_type", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_type(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_type", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_type"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_type"); + } + + ThriftHiveMetastore_drop_type_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_type", bytes); + } + + ThriftHiveMetastore_drop_type_result result; + try { + result.success = iface_->drop_type(args.type); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_type"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_type", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_type"); + } + + oprot->writeMessageBegin("drop_type", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_type", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_type_all(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_type_all", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_type_all"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_type_all"); + } + + ThriftHiveMetastore_get_type_all_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_type_all", bytes); + } + + ThriftHiveMetastore_get_type_all_result result; + try { + iface_->get_type_all(result.success, args.name); + result.__isset.success = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_type_all"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_type_all", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_type_all"); + } + + oprot->writeMessageBegin("get_type_all", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_type_all", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_fields(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_fields", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_fields"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_fields"); + } + + ThriftHiveMetastore_get_fields_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_fields", bytes); + } + + ThriftHiveMetastore_get_fields_result result; + try { + iface_->get_fields(result.success, args.db_name, args.table_name); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (UnknownTableException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (UnknownDBException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_fields"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_fields", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_fields"); + } + + oprot->writeMessageBegin("get_fields", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_fields", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_fields_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_fields_with_environment_context", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_fields_with_environment_context"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_fields_with_environment_context"); + } + + ThriftHiveMetastore_get_fields_with_environment_context_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_fields_with_environment_context", bytes); + } + + ThriftHiveMetastore_get_fields_with_environment_context_result result; + try { + iface_->get_fields_with_environment_context(result.success, args.db_name, args.table_name, args.environment_context); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (UnknownTableException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (UnknownDBException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_fields_with_environment_context"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_fields_with_environment_context", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_fields_with_environment_context"); + } + + oprot->writeMessageBegin("get_fields_with_environment_context", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_fields_with_environment_context", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_fields_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_fields_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_fields_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_fields_req"); + } + + ThriftHiveMetastore_get_fields_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_fields_req", bytes); + } + + ThriftHiveMetastore_get_fields_req_result result; + try { + iface_->get_fields_req(result.success, args.req); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (UnknownTableException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (UnknownDBException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_fields_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_fields_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_fields_req"); + } + + oprot->writeMessageBegin("get_fields_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_fields_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_schema(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_schema", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_schema"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_schema"); + } + + ThriftHiveMetastore_get_schema_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_schema", bytes); + } + + ThriftHiveMetastore_get_schema_result result; + try { + iface_->get_schema(result.success, args.db_name, args.table_name); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (UnknownTableException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (UnknownDBException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_schema"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_schema", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_schema"); + } + + oprot->writeMessageBegin("get_schema", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_schema", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_schema_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_schema_with_environment_context", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_schema_with_environment_context"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_schema_with_environment_context"); + } + + ThriftHiveMetastore_get_schema_with_environment_context_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_schema_with_environment_context", bytes); + } + + ThriftHiveMetastore_get_schema_with_environment_context_result result; + try { + iface_->get_schema_with_environment_context(result.success, args.db_name, args.table_name, args.environment_context); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (UnknownTableException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (UnknownDBException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_schema_with_environment_context"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_schema_with_environment_context", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_schema_with_environment_context"); + } + + oprot->writeMessageBegin("get_schema_with_environment_context", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_schema_with_environment_context", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_schema_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_schema_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_schema_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_schema_req"); + } + + ThriftHiveMetastore_get_schema_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_schema_req", bytes); + } + + ThriftHiveMetastore_get_schema_req_result result; + try { + iface_->get_schema_req(result.success, args.req); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (UnknownTableException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (UnknownDBException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_schema_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_schema_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_schema_req"); + } + + oprot->writeMessageBegin("get_schema_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_schema_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_create_table(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.create_table", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.create_table"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.create_table"); + } + + ThriftHiveMetastore_create_table_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.create_table", bytes); + } + + ThriftHiveMetastore_create_table_result result; + try { + iface_->create_table(args.tbl); + } catch (AlreadyExistsException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (NoSuchObjectException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.create_table"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("create_table", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.create_table"); + } + + oprot->writeMessageBegin("create_table", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.create_table", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_create_table_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.create_table_with_environment_context", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.create_table_with_environment_context"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.create_table_with_environment_context"); + } + + ThriftHiveMetastore_create_table_with_environment_context_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.create_table_with_environment_context", bytes); + } + + ThriftHiveMetastore_create_table_with_environment_context_result result; + try { + iface_->create_table_with_environment_context(args.tbl, args.environment_context); + } catch (AlreadyExistsException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (NoSuchObjectException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.create_table_with_environment_context"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("create_table_with_environment_context", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.create_table_with_environment_context"); + } + + oprot->writeMessageBegin("create_table_with_environment_context", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.create_table_with_environment_context", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_create_table_with_constraints(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.create_table_with_constraints", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.create_table_with_constraints"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.create_table_with_constraints"); + } + + ThriftHiveMetastore_create_table_with_constraints_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.create_table_with_constraints", bytes); + } + + ThriftHiveMetastore_create_table_with_constraints_result result; + try { + iface_->create_table_with_constraints(args.tbl, args.primaryKeys, args.foreignKeys, args.uniqueConstraints, args.notNullConstraints, args.defaultConstraints, args.checkConstraints); + } catch (AlreadyExistsException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (NoSuchObjectException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.create_table_with_constraints"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("create_table_with_constraints", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.create_table_with_constraints"); + } + + oprot->writeMessageBegin("create_table_with_constraints", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.create_table_with_constraints", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_create_table_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.create_table_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.create_table_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.create_table_req"); + } + + ThriftHiveMetastore_create_table_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.create_table_req", bytes); + } + + ThriftHiveMetastore_create_table_req_result result; + try { + iface_->create_table_req(args.request); + } catch (AlreadyExistsException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (NoSuchObjectException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.create_table_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("create_table_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.create_table_req"); + } + + oprot->writeMessageBegin("create_table_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.create_table_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_constraint(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_constraint", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_constraint"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_constraint"); + } + + ThriftHiveMetastore_drop_constraint_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_constraint", bytes); + } + + ThriftHiveMetastore_drop_constraint_result result; + try { + iface_->drop_constraint(args.req); + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_constraint"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_constraint", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_constraint"); + } + + oprot->writeMessageBegin("drop_constraint", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_constraint", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_add_primary_key(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.add_primary_key", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.add_primary_key"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.add_primary_key"); + } + + ThriftHiveMetastore_add_primary_key_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.add_primary_key", bytes); + } + + ThriftHiveMetastore_add_primary_key_result result; + try { + iface_->add_primary_key(args.req); + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.add_primary_key"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("add_primary_key", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.add_primary_key"); + } + + oprot->writeMessageBegin("add_primary_key", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.add_primary_key", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_add_foreign_key(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.add_foreign_key", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.add_foreign_key"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.add_foreign_key"); + } + + ThriftHiveMetastore_add_foreign_key_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.add_foreign_key", bytes); + } + + ThriftHiveMetastore_add_foreign_key_result result; + try { + iface_->add_foreign_key(args.req); + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.add_foreign_key"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("add_foreign_key", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.add_foreign_key"); + } + + oprot->writeMessageBegin("add_foreign_key", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.add_foreign_key", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_add_unique_constraint(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.add_unique_constraint", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.add_unique_constraint"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.add_unique_constraint"); + } + + ThriftHiveMetastore_add_unique_constraint_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.add_unique_constraint", bytes); + } + + ThriftHiveMetastore_add_unique_constraint_result result; + try { + iface_->add_unique_constraint(args.req); + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.add_unique_constraint"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("add_unique_constraint", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.add_unique_constraint"); + } + + oprot->writeMessageBegin("add_unique_constraint", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.add_unique_constraint", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_add_not_null_constraint(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.add_not_null_constraint", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.add_not_null_constraint"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.add_not_null_constraint"); + } + + ThriftHiveMetastore_add_not_null_constraint_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.add_not_null_constraint", bytes); + } + + ThriftHiveMetastore_add_not_null_constraint_result result; + try { + iface_->add_not_null_constraint(args.req); + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.add_not_null_constraint"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("add_not_null_constraint", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.add_not_null_constraint"); + } + + oprot->writeMessageBegin("add_not_null_constraint", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.add_not_null_constraint", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_add_default_constraint(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.add_default_constraint", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.add_default_constraint"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.add_default_constraint"); + } + + ThriftHiveMetastore_add_default_constraint_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.add_default_constraint", bytes); + } + + ThriftHiveMetastore_add_default_constraint_result result; + try { + iface_->add_default_constraint(args.req); + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.add_default_constraint"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("add_default_constraint", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.add_default_constraint"); + } + + oprot->writeMessageBegin("add_default_constraint", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.add_default_constraint", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_add_check_constraint(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.add_check_constraint", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.add_check_constraint"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.add_check_constraint"); + } + + ThriftHiveMetastore_add_check_constraint_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.add_check_constraint", bytes); + } + + ThriftHiveMetastore_add_check_constraint_result result; + try { + iface_->add_check_constraint(args.req); + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.add_check_constraint"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("add_check_constraint", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.add_check_constraint"); + } + + oprot->writeMessageBegin("add_check_constraint", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.add_check_constraint", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_translate_table_dryrun(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.translate_table_dryrun", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.translate_table_dryrun"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.translate_table_dryrun"); + } + + ThriftHiveMetastore_translate_table_dryrun_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.translate_table_dryrun", bytes); + } + + ThriftHiveMetastore_translate_table_dryrun_result result; + try { + iface_->translate_table_dryrun(result.success, args.request); + result.__isset.success = true; + } catch (AlreadyExistsException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (NoSuchObjectException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.translate_table_dryrun"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("translate_table_dryrun", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.translate_table_dryrun"); + } + + oprot->writeMessageBegin("translate_table_dryrun", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.translate_table_dryrun", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_table(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_table", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_table"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_table"); + } + + ThriftHiveMetastore_drop_table_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_table", bytes); + } + + ThriftHiveMetastore_drop_table_result result; + try { + iface_->drop_table(args.dbname, args.name, args.deleteData); + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_table"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_table", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_table"); + } + + oprot->writeMessageBegin("drop_table", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_table", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_table_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_table_with_environment_context", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_table_with_environment_context"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_table_with_environment_context"); + } + + ThriftHiveMetastore_drop_table_with_environment_context_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_table_with_environment_context", bytes); + } + + ThriftHiveMetastore_drop_table_with_environment_context_result result; + try { + iface_->drop_table_with_environment_context(args.dbname, args.name, args.deleteData, args.environment_context); + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_table_with_environment_context"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_table_with_environment_context", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_table_with_environment_context"); + } + + oprot->writeMessageBegin("drop_table_with_environment_context", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_table_with_environment_context", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_table_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_table_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_table_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_table_req"); + } + + ThriftHiveMetastore_drop_table_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_table_req", bytes); + } + + ThriftHiveMetastore_drop_table_req_result result; + try { + iface_->drop_table_req(args.dropTableReq); + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_table_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_table_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_table_req"); + } + + oprot->writeMessageBegin("drop_table_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_table_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_truncate_table(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.truncate_table", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.truncate_table"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.truncate_table"); + } + + ThriftHiveMetastore_truncate_table_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.truncate_table", bytes); + } + + ThriftHiveMetastore_truncate_table_result result; + try { + iface_->truncate_table(args.dbName, args.tableName, args.partNames); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.truncate_table"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("truncate_table", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.truncate_table"); + } + + oprot->writeMessageBegin("truncate_table", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.truncate_table", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_truncate_table_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.truncate_table_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.truncate_table_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.truncate_table_req"); + } + + ThriftHiveMetastore_truncate_table_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.truncate_table_req", bytes); + } + + ThriftHiveMetastore_truncate_table_req_result result; + try { + iface_->truncate_table_req(result.success, args.req); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.truncate_table_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("truncate_table_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.truncate_table_req"); + } + + oprot->writeMessageBegin("truncate_table_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.truncate_table_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_tables(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_tables", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_tables"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_tables"); + } + + ThriftHiveMetastore_get_tables_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_tables", bytes); + } + + ThriftHiveMetastore_get_tables_result result; + try { + iface_->get_tables(result.success, args.db_name, args.pattern); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_tables"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_tables", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_tables"); + } + + oprot->writeMessageBegin("get_tables", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_tables", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_tables_by_type(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_tables_by_type", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_tables_by_type"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_tables_by_type"); + } + + ThriftHiveMetastore_get_tables_by_type_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_tables_by_type", bytes); + } + + ThriftHiveMetastore_get_tables_by_type_result result; + try { + iface_->get_tables_by_type(result.success, args.db_name, args.pattern, args.tableType); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_tables_by_type"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_tables_by_type", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_tables_by_type"); + } + + oprot->writeMessageBegin("get_tables_by_type", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_tables_by_type", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_all_materialized_view_objects_for_rewriting(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_all_materialized_view_objects_for_rewriting", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_all_materialized_view_objects_for_rewriting"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_all_materialized_view_objects_for_rewriting"); + } + + ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_all_materialized_view_objects_for_rewriting", bytes); + } + + ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_result result; + try { + iface_->get_all_materialized_view_objects_for_rewriting(result.success); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_all_materialized_view_objects_for_rewriting"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_all_materialized_view_objects_for_rewriting", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_all_materialized_view_objects_for_rewriting"); + } + + oprot->writeMessageBegin("get_all_materialized_view_objects_for_rewriting", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_all_materialized_view_objects_for_rewriting", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_materialized_views_for_rewriting(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_materialized_views_for_rewriting", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_materialized_views_for_rewriting"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_materialized_views_for_rewriting"); + } + + ThriftHiveMetastore_get_materialized_views_for_rewriting_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_materialized_views_for_rewriting", bytes); + } + + ThriftHiveMetastore_get_materialized_views_for_rewriting_result result; + try { + iface_->get_materialized_views_for_rewriting(result.success, args.db_name); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_materialized_views_for_rewriting"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_materialized_views_for_rewriting", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_materialized_views_for_rewriting"); + } + + oprot->writeMessageBegin("get_materialized_views_for_rewriting", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_materialized_views_for_rewriting", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_table_meta(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_table_meta", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_table_meta"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_table_meta"); + } + + ThriftHiveMetastore_get_table_meta_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_table_meta", bytes); + } + + ThriftHiveMetastore_get_table_meta_result result; + try { + iface_->get_table_meta(result.success, args.db_patterns, args.tbl_patterns, args.tbl_types); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_table_meta"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_table_meta", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_table_meta"); + } + + oprot->writeMessageBegin("get_table_meta", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_table_meta", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_all_tables(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_all_tables", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_all_tables"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_all_tables"); + } + + ThriftHiveMetastore_get_all_tables_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_all_tables", bytes); + } + + ThriftHiveMetastore_get_all_tables_result result; + try { + iface_->get_all_tables(result.success, args.db_name); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_all_tables"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_all_tables", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_all_tables"); + } + + oprot->writeMessageBegin("get_all_tables", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_all_tables", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_tables_ext(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_tables_ext", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_tables_ext"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_tables_ext"); + } + + ThriftHiveMetastore_get_tables_ext_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_tables_ext", bytes); + } + + ThriftHiveMetastore_get_tables_ext_result result; + try { + iface_->get_tables_ext(result.success, args.req); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_tables_ext"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_tables_ext", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_tables_ext"); + } + + oprot->writeMessageBegin("get_tables_ext", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_tables_ext", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_table_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_table_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_table_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_table_req"); + } + + ThriftHiveMetastore_get_table_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_table_req", bytes); + } + + ThriftHiveMetastore_get_table_req_result result; + try { + iface_->get_table_req(result.success, args.req); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_table_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_table_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_table_req"); + } + + oprot->writeMessageBegin("get_table_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_table_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_table_objects_by_name_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_table_objects_by_name_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_table_objects_by_name_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_table_objects_by_name_req"); + } + + ThriftHiveMetastore_get_table_objects_by_name_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_table_objects_by_name_req", bytes); + } + + ThriftHiveMetastore_get_table_objects_by_name_req_result result; + try { + iface_->get_table_objects_by_name_req(result.success, args.req); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidOperationException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (UnknownDBException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_table_objects_by_name_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_table_objects_by_name_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_table_objects_by_name_req"); + } + + oprot->writeMessageBegin("get_table_objects_by_name_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_table_objects_by_name_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_materialization_invalidation_info(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_materialization_invalidation_info", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_materialization_invalidation_info"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_materialization_invalidation_info"); + } + + ThriftHiveMetastore_get_materialization_invalidation_info_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_materialization_invalidation_info", bytes); + } + + ThriftHiveMetastore_get_materialization_invalidation_info_result result; + try { + iface_->get_materialization_invalidation_info(result.success, args.creation_metadata, args.validTxnList); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidOperationException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (UnknownDBException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_materialization_invalidation_info"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_materialization_invalidation_info", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_materialization_invalidation_info"); + } + + oprot->writeMessageBegin("get_materialization_invalidation_info", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_materialization_invalidation_info", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_update_creation_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.update_creation_metadata", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.update_creation_metadata"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.update_creation_metadata"); + } + + ThriftHiveMetastore_update_creation_metadata_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.update_creation_metadata", bytes); + } + + ThriftHiveMetastore_update_creation_metadata_result result; + try { + iface_->update_creation_metadata(args.catName, args.dbname, args.tbl_name, args.creation_metadata); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidOperationException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (UnknownDBException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.update_creation_metadata"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("update_creation_metadata", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.update_creation_metadata"); + } + + oprot->writeMessageBegin("update_creation_metadata", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.update_creation_metadata", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_table_names_by_filter(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_table_names_by_filter", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_table_names_by_filter"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_table_names_by_filter"); + } + + ThriftHiveMetastore_get_table_names_by_filter_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_table_names_by_filter", bytes); + } + + ThriftHiveMetastore_get_table_names_by_filter_result result; + try { + iface_->get_table_names_by_filter(result.success, args.dbname, args.filter, args.max_tables); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidOperationException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (UnknownDBException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_table_names_by_filter"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_table_names_by_filter", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_table_names_by_filter"); + } + + oprot->writeMessageBegin("get_table_names_by_filter", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_table_names_by_filter", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_alter_table(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.alter_table", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.alter_table"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.alter_table"); + } + + ThriftHiveMetastore_alter_table_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.alter_table", bytes); + } + + ThriftHiveMetastore_alter_table_result result; + try { + iface_->alter_table(args.dbname, args.tbl_name, args.new_tbl); + } catch (InvalidOperationException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.alter_table"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("alter_table", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.alter_table"); + } + + oprot->writeMessageBegin("alter_table", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.alter_table", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_alter_table_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.alter_table_with_environment_context", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.alter_table_with_environment_context"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.alter_table_with_environment_context"); + } + + ThriftHiveMetastore_alter_table_with_environment_context_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.alter_table_with_environment_context", bytes); + } + + ThriftHiveMetastore_alter_table_with_environment_context_result result; + try { + iface_->alter_table_with_environment_context(args.dbname, args.tbl_name, args.new_tbl, args.environment_context); + } catch (InvalidOperationException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.alter_table_with_environment_context"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("alter_table_with_environment_context", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.alter_table_with_environment_context"); + } + + oprot->writeMessageBegin("alter_table_with_environment_context", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.alter_table_with_environment_context", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_alter_table_with_cascade(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.alter_table_with_cascade", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.alter_table_with_cascade"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.alter_table_with_cascade"); + } + + ThriftHiveMetastore_alter_table_with_cascade_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.alter_table_with_cascade", bytes); + } + + ThriftHiveMetastore_alter_table_with_cascade_result result; + try { + iface_->alter_table_with_cascade(args.dbname, args.tbl_name, args.new_tbl, args.cascade); + } catch (InvalidOperationException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.alter_table_with_cascade"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("alter_table_with_cascade", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.alter_table_with_cascade"); + } + + oprot->writeMessageBegin("alter_table_with_cascade", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.alter_table_with_cascade", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_alter_table_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.alter_table_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.alter_table_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.alter_table_req"); + } + + ThriftHiveMetastore_alter_table_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.alter_table_req", bytes); + } + + ThriftHiveMetastore_alter_table_req_result result; + try { + iface_->alter_table_req(result.success, args.req); + result.__isset.success = true; + } catch (InvalidOperationException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.alter_table_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("alter_table_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.alter_table_req"); + } + + oprot->writeMessageBegin("alter_table_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.alter_table_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_add_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.add_partition", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.add_partition"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.add_partition"); + } + + ThriftHiveMetastore_add_partition_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.add_partition", bytes); + } + + ThriftHiveMetastore_add_partition_result result; + try { + iface_->add_partition(result.success, args.new_part); + result.__isset.success = true; + } catch (InvalidObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (AlreadyExistsException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.add_partition"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("add_partition", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.add_partition"); + } + + oprot->writeMessageBegin("add_partition", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.add_partition", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_add_partition_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.add_partition_with_environment_context", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.add_partition_with_environment_context"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.add_partition_with_environment_context"); + } + + ThriftHiveMetastore_add_partition_with_environment_context_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.add_partition_with_environment_context", bytes); + } + + ThriftHiveMetastore_add_partition_with_environment_context_result result; + try { + iface_->add_partition_with_environment_context(result.success, args.new_part, args.environment_context); + result.__isset.success = true; + } catch (InvalidObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (AlreadyExistsException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.add_partition_with_environment_context"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("add_partition_with_environment_context", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.add_partition_with_environment_context"); + } + + oprot->writeMessageBegin("add_partition_with_environment_context", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.add_partition_with_environment_context", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_add_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.add_partitions", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.add_partitions"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.add_partitions"); + } + + ThriftHiveMetastore_add_partitions_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.add_partitions", bytes); + } + + ThriftHiveMetastore_add_partitions_result result; + try { + result.success = iface_->add_partitions(args.new_parts); + result.__isset.success = true; + } catch (InvalidObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (AlreadyExistsException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.add_partitions"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("add_partitions", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.add_partitions"); + } + + oprot->writeMessageBegin("add_partitions", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.add_partitions", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_add_partitions_pspec(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.add_partitions_pspec", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.add_partitions_pspec"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.add_partitions_pspec"); + } + + ThriftHiveMetastore_add_partitions_pspec_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.add_partitions_pspec", bytes); + } + + ThriftHiveMetastore_add_partitions_pspec_result result; + try { + result.success = iface_->add_partitions_pspec(args.new_parts); + result.__isset.success = true; + } catch (InvalidObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (AlreadyExistsException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.add_partitions_pspec"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("add_partitions_pspec", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.add_partitions_pspec"); + } + + oprot->writeMessageBegin("add_partitions_pspec", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.add_partitions_pspec", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_append_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.append_partition", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.append_partition"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.append_partition"); + } + + ThriftHiveMetastore_append_partition_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.append_partition", bytes); + } + + ThriftHiveMetastore_append_partition_result result; + try { + iface_->append_partition(result.success, args.db_name, args.tbl_name, args.part_vals); + result.__isset.success = true; + } catch (InvalidObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (AlreadyExistsException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.append_partition"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("append_partition", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.append_partition"); + } + + oprot->writeMessageBegin("append_partition", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.append_partition", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_add_partitions_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.add_partitions_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.add_partitions_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.add_partitions_req"); + } + + ThriftHiveMetastore_add_partitions_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.add_partitions_req", bytes); + } + + ThriftHiveMetastore_add_partitions_req_result result; + try { + iface_->add_partitions_req(result.success, args.request); + result.__isset.success = true; + } catch (InvalidObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (AlreadyExistsException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.add_partitions_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("add_partitions_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.add_partitions_req"); + } + + oprot->writeMessageBegin("add_partitions_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.add_partitions_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_append_partition_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.append_partition_with_environment_context", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.append_partition_with_environment_context"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.append_partition_with_environment_context"); + } + + ThriftHiveMetastore_append_partition_with_environment_context_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.append_partition_with_environment_context", bytes); + } + + ThriftHiveMetastore_append_partition_with_environment_context_result result; + try { + iface_->append_partition_with_environment_context(result.success, args.db_name, args.tbl_name, args.part_vals, args.environment_context); + result.__isset.success = true; + } catch (InvalidObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (AlreadyExistsException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.append_partition_with_environment_context"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("append_partition_with_environment_context", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.append_partition_with_environment_context"); + } + + oprot->writeMessageBegin("append_partition_with_environment_context", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.append_partition_with_environment_context", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_append_partition_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.append_partition_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.append_partition_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.append_partition_req"); + } + + ThriftHiveMetastore_append_partition_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.append_partition_req", bytes); + } + + ThriftHiveMetastore_append_partition_req_result result; + try { + iface_->append_partition_req(result.success, args.appendPartitionsReq); + result.__isset.success = true; + } catch (InvalidObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (AlreadyExistsException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.append_partition_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("append_partition_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.append_partition_req"); + } + + oprot->writeMessageBegin("append_partition_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.append_partition_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_append_partition_by_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.append_partition_by_name", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.append_partition_by_name"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.append_partition_by_name"); + } + + ThriftHiveMetastore_append_partition_by_name_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.append_partition_by_name", bytes); + } + + ThriftHiveMetastore_append_partition_by_name_result result; + try { + iface_->append_partition_by_name(result.success, args.db_name, args.tbl_name, args.part_name); + result.__isset.success = true; + } catch (InvalidObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (AlreadyExistsException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.append_partition_by_name"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("append_partition_by_name", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.append_partition_by_name"); + } + + oprot->writeMessageBegin("append_partition_by_name", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.append_partition_by_name", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_append_partition_by_name_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.append_partition_by_name_with_environment_context", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.append_partition_by_name_with_environment_context"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.append_partition_by_name_with_environment_context"); + } + + ThriftHiveMetastore_append_partition_by_name_with_environment_context_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.append_partition_by_name_with_environment_context", bytes); + } + + ThriftHiveMetastore_append_partition_by_name_with_environment_context_result result; + try { + iface_->append_partition_by_name_with_environment_context(result.success, args.db_name, args.tbl_name, args.part_name, args.environment_context); + result.__isset.success = true; + } catch (InvalidObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (AlreadyExistsException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.append_partition_by_name_with_environment_context"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("append_partition_by_name_with_environment_context", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.append_partition_by_name_with_environment_context"); + } + + oprot->writeMessageBegin("append_partition_by_name_with_environment_context", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.append_partition_by_name_with_environment_context", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_partition", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_partition"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_partition"); + } + + ThriftHiveMetastore_drop_partition_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_partition", bytes); + } + + ThriftHiveMetastore_drop_partition_result result; + try { + result.success = iface_->drop_partition(args.db_name, args.tbl_name, args.part_vals, args.deleteData); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_partition"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_partition", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_partition"); + } + + oprot->writeMessageBegin("drop_partition", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_partition", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_partition_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_partition_with_environment_context", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_partition_with_environment_context"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_partition_with_environment_context"); + } + + ThriftHiveMetastore_drop_partition_with_environment_context_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_partition_with_environment_context", bytes); + } + + ThriftHiveMetastore_drop_partition_with_environment_context_result result; + try { + result.success = iface_->drop_partition_with_environment_context(args.db_name, args.tbl_name, args.part_vals, args.deleteData, args.environment_context); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_partition_with_environment_context"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_partition_with_environment_context", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_partition_with_environment_context"); + } + + oprot->writeMessageBegin("drop_partition_with_environment_context", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_partition_with_environment_context", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_partition_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_partition_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_partition_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_partition_req"); + } + + ThriftHiveMetastore_drop_partition_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_partition_req", bytes); + } + + ThriftHiveMetastore_drop_partition_req_result result; + try { + result.success = iface_->drop_partition_req(args.dropPartitionReq); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_partition_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_partition_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_partition_req"); + } + + oprot->writeMessageBegin("drop_partition_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_partition_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_partition_by_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_partition_by_name", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_partition_by_name"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_partition_by_name"); + } + + ThriftHiveMetastore_drop_partition_by_name_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_partition_by_name", bytes); + } + + ThriftHiveMetastore_drop_partition_by_name_result result; + try { + result.success = iface_->drop_partition_by_name(args.db_name, args.tbl_name, args.part_name, args.deleteData); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_partition_by_name"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_partition_by_name", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_partition_by_name"); + } + + oprot->writeMessageBegin("drop_partition_by_name", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_partition_by_name", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_partition_by_name_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_partition_by_name_with_environment_context", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_partition_by_name_with_environment_context"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_partition_by_name_with_environment_context"); + } + + ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_partition_by_name_with_environment_context", bytes); + } + + ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result result; + try { + result.success = iface_->drop_partition_by_name_with_environment_context(args.db_name, args.tbl_name, args.part_name, args.deleteData, args.environment_context); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_partition_by_name_with_environment_context"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_partition_by_name_with_environment_context", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_partition_by_name_with_environment_context"); + } + + oprot->writeMessageBegin("drop_partition_by_name_with_environment_context", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_partition_by_name_with_environment_context", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_partitions_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_partitions_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_partitions_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_partitions_req"); + } + + ThriftHiveMetastore_drop_partitions_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_partitions_req", bytes); + } + + ThriftHiveMetastore_drop_partitions_req_result result; + try { + iface_->drop_partitions_req(result.success, args.req); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_partitions_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_partitions_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_partitions_req"); + } + + oprot->writeMessageBegin("drop_partitions_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_partitions_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partition", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partition"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partition"); + } + + ThriftHiveMetastore_get_partition_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partition", bytes); + } + + ThriftHiveMetastore_get_partition_result result; + try { + iface_->get_partition(result.success, args.db_name, args.tbl_name, args.part_vals); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partition"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partition", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partition"); + } + + oprot->writeMessageBegin("get_partition", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partition", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partition_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partition_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partition_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partition_req"); + } + + ThriftHiveMetastore_get_partition_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partition_req", bytes); + } + + ThriftHiveMetastore_get_partition_req_result result; + try { + iface_->get_partition_req(result.success, args.req); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partition_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partition_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partition_req"); + } + + oprot->writeMessageBegin("get_partition_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partition_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_exchange_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.exchange_partition", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.exchange_partition"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.exchange_partition"); + } + + ThriftHiveMetastore_exchange_partition_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.exchange_partition", bytes); + } + + ThriftHiveMetastore_exchange_partition_result result; + try { + iface_->exchange_partition(result.success, args.partitionSpecs, args.source_db, args.source_table_name, args.dest_db, args.dest_table_name); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (InvalidObjectException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (InvalidInputException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.exchange_partition"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("exchange_partition", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.exchange_partition"); + } + + oprot->writeMessageBegin("exchange_partition", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.exchange_partition", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_exchange_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.exchange_partitions", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.exchange_partitions"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.exchange_partitions"); + } + + ThriftHiveMetastore_exchange_partitions_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.exchange_partitions", bytes); + } + + ThriftHiveMetastore_exchange_partitions_result result; + try { + iface_->exchange_partitions(result.success, args.partitionSpecs, args.source_db, args.source_table_name, args.dest_db, args.dest_table_name); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (InvalidObjectException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (InvalidInputException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.exchange_partitions"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("exchange_partitions", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.exchange_partitions"); + } + + oprot->writeMessageBegin("exchange_partitions", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.exchange_partitions", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partition_with_auth(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partition_with_auth", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partition_with_auth"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partition_with_auth"); + } + + ThriftHiveMetastore_get_partition_with_auth_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partition_with_auth", bytes); + } + + ThriftHiveMetastore_get_partition_with_auth_result result; + try { + iface_->get_partition_with_auth(result.success, args.db_name, args.tbl_name, args.part_vals, args.user_name, args.group_names); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partition_with_auth"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partition_with_auth", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partition_with_auth"); + } + + oprot->writeMessageBegin("get_partition_with_auth", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partition_with_auth", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partition_by_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partition_by_name", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partition_by_name"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partition_by_name"); + } + + ThriftHiveMetastore_get_partition_by_name_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partition_by_name", bytes); + } + + ThriftHiveMetastore_get_partition_by_name_result result; + try { + iface_->get_partition_by_name(result.success, args.db_name, args.tbl_name, args.part_name); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partition_by_name"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partition_by_name", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partition_by_name"); + } + + oprot->writeMessageBegin("get_partition_by_name", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partition_by_name", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partitions", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partitions"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partitions"); + } + + ThriftHiveMetastore_get_partitions_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partitions", bytes); + } + + ThriftHiveMetastore_get_partitions_result result; + try { + iface_->get_partitions(result.success, args.db_name, args.tbl_name, args.max_parts); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partitions"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partitions", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partitions"); + } + + oprot->writeMessageBegin("get_partitions", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partitions", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partitions_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partitions_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partitions_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partitions_req"); + } + + ThriftHiveMetastore_get_partitions_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partitions_req", bytes); + } + + ThriftHiveMetastore_get_partitions_req_result result; + try { + iface_->get_partitions_req(result.success, args.req); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partitions_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partitions_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partitions_req"); + } + + oprot->writeMessageBegin("get_partitions_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partitions_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partitions_with_auth(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partitions_with_auth", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partitions_with_auth"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partitions_with_auth"); + } + + ThriftHiveMetastore_get_partitions_with_auth_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partitions_with_auth", bytes); + } + + ThriftHiveMetastore_get_partitions_with_auth_result result; + try { + iface_->get_partitions_with_auth(result.success, args.db_name, args.tbl_name, args.max_parts, args.user_name, args.group_names); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partitions_with_auth"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partitions_with_auth", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partitions_with_auth"); + } + + oprot->writeMessageBegin("get_partitions_with_auth", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partitions_with_auth", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partitions_pspec(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partitions_pspec", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partitions_pspec"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partitions_pspec"); + } + + ThriftHiveMetastore_get_partitions_pspec_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partitions_pspec", bytes); + } + + ThriftHiveMetastore_get_partitions_pspec_result result; + try { + iface_->get_partitions_pspec(result.success, args.db_name, args.tbl_name, args.max_parts); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partitions_pspec"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partitions_pspec", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partitions_pspec"); + } + + oprot->writeMessageBegin("get_partitions_pspec", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partitions_pspec", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partition_names(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partition_names", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partition_names"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partition_names"); + } + + ThriftHiveMetastore_get_partition_names_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partition_names", bytes); + } + + ThriftHiveMetastore_get_partition_names_result result; + try { + iface_->get_partition_names(result.success, args.db_name, args.tbl_name, args.max_parts); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partition_names"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partition_names", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partition_names"); + } + + oprot->writeMessageBegin("get_partition_names", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partition_names", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_fetch_partition_names_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.fetch_partition_names_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.fetch_partition_names_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.fetch_partition_names_req"); + } + + ThriftHiveMetastore_fetch_partition_names_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.fetch_partition_names_req", bytes); + } + + ThriftHiveMetastore_fetch_partition_names_req_result result; + try { + iface_->fetch_partition_names_req(result.success, args.partitionReq); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.fetch_partition_names_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("fetch_partition_names_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.fetch_partition_names_req"); + } + + oprot->writeMessageBegin("fetch_partition_names_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.fetch_partition_names_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partition_values(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partition_values", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partition_values"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partition_values"); + } + + ThriftHiveMetastore_get_partition_values_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partition_values", bytes); + } + + ThriftHiveMetastore_get_partition_values_result result; + try { + iface_->get_partition_values(result.success, args.request); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partition_values"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partition_values", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partition_values"); + } + + oprot->writeMessageBegin("get_partition_values", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partition_values", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partitions_ps(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partitions_ps", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partitions_ps"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partitions_ps"); + } + + ThriftHiveMetastore_get_partitions_ps_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partitions_ps", bytes); + } + + ThriftHiveMetastore_get_partitions_ps_result result; + try { + iface_->get_partitions_ps(result.success, args.db_name, args.tbl_name, args.part_vals, args.max_parts); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partitions_ps"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partitions_ps", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partitions_ps"); + } + + oprot->writeMessageBegin("get_partitions_ps", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partitions_ps", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partitions_ps_with_auth(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partitions_ps_with_auth", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partitions_ps_with_auth"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partitions_ps_with_auth"); + } + + ThriftHiveMetastore_get_partitions_ps_with_auth_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partitions_ps_with_auth", bytes); + } + + ThriftHiveMetastore_get_partitions_ps_with_auth_result result; + try { + iface_->get_partitions_ps_with_auth(result.success, args.db_name, args.tbl_name, args.part_vals, args.max_parts, args.user_name, args.group_names); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partitions_ps_with_auth"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partitions_ps_with_auth", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partitions_ps_with_auth"); + } + + oprot->writeMessageBegin("get_partitions_ps_with_auth", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partitions_ps_with_auth", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partitions_ps_with_auth_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partitions_ps_with_auth_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partitions_ps_with_auth_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partitions_ps_with_auth_req"); + } + + ThriftHiveMetastore_get_partitions_ps_with_auth_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partitions_ps_with_auth_req", bytes); + } + + ThriftHiveMetastore_get_partitions_ps_with_auth_req_result result; + try { + iface_->get_partitions_ps_with_auth_req(result.success, args.req); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partitions_ps_with_auth_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partitions_ps_with_auth_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partitions_ps_with_auth_req"); + } + + oprot->writeMessageBegin("get_partitions_ps_with_auth_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partitions_ps_with_auth_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partition_names_ps(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partition_names_ps", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partition_names_ps"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partition_names_ps"); + } + + ThriftHiveMetastore_get_partition_names_ps_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partition_names_ps", bytes); + } + + ThriftHiveMetastore_get_partition_names_ps_result result; + try { + iface_->get_partition_names_ps(result.success, args.db_name, args.tbl_name, args.part_vals, args.max_parts); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partition_names_ps"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partition_names_ps", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partition_names_ps"); + } + + oprot->writeMessageBegin("get_partition_names_ps", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partition_names_ps", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partition_names_ps_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partition_names_ps_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partition_names_ps_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partition_names_ps_req"); + } + + ThriftHiveMetastore_get_partition_names_ps_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partition_names_ps_req", bytes); + } + + ThriftHiveMetastore_get_partition_names_ps_req_result result; + try { + iface_->get_partition_names_ps_req(result.success, args.req); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partition_names_ps_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partition_names_ps_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partition_names_ps_req"); + } + + oprot->writeMessageBegin("get_partition_names_ps_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partition_names_ps_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partition_names_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partition_names_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partition_names_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partition_names_req"); + } + + ThriftHiveMetastore_get_partition_names_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partition_names_req", bytes); + } + + ThriftHiveMetastore_get_partition_names_req_result result; + try { + iface_->get_partition_names_req(result.success, args.req); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partition_names_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partition_names_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partition_names_req"); + } + + oprot->writeMessageBegin("get_partition_names_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partition_names_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partitions_by_filter(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partitions_by_filter", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partitions_by_filter"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partitions_by_filter"); + } + + ThriftHiveMetastore_get_partitions_by_filter_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partitions_by_filter", bytes); + } + + ThriftHiveMetastore_get_partitions_by_filter_result result; + try { + iface_->get_partitions_by_filter(result.success, args.db_name, args.tbl_name, args.filter, args.max_parts); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partitions_by_filter"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partitions_by_filter", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partitions_by_filter"); + } + + oprot->writeMessageBegin("get_partitions_by_filter", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partitions_by_filter", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partitions_by_filter_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partitions_by_filter_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partitions_by_filter_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partitions_by_filter_req"); + } + + ThriftHiveMetastore_get_partitions_by_filter_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partitions_by_filter_req", bytes); + } + + ThriftHiveMetastore_get_partitions_by_filter_req_result result; + try { + iface_->get_partitions_by_filter_req(result.success, args.req); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partitions_by_filter_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partitions_by_filter_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partitions_by_filter_req"); + } + + oprot->writeMessageBegin("get_partitions_by_filter_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partitions_by_filter_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_part_specs_by_filter(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_part_specs_by_filter", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_part_specs_by_filter"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_part_specs_by_filter"); + } + + ThriftHiveMetastore_get_part_specs_by_filter_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_part_specs_by_filter", bytes); + } + + ThriftHiveMetastore_get_part_specs_by_filter_result result; + try { + iface_->get_part_specs_by_filter(result.success, args.db_name, args.tbl_name, args.filter, args.max_parts); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_part_specs_by_filter"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_part_specs_by_filter", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_part_specs_by_filter"); + } + + oprot->writeMessageBegin("get_part_specs_by_filter", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_part_specs_by_filter", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partitions_by_expr(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partitions_by_expr", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partitions_by_expr"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partitions_by_expr"); + } + + ThriftHiveMetastore_get_partitions_by_expr_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partitions_by_expr", bytes); + } + + ThriftHiveMetastore_get_partitions_by_expr_result result; + try { + iface_->get_partitions_by_expr(result.success, args.req); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partitions_by_expr"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partitions_by_expr", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partitions_by_expr"); + } + + oprot->writeMessageBegin("get_partitions_by_expr", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partitions_by_expr", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partitions_spec_by_expr(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partitions_spec_by_expr", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partitions_spec_by_expr"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partitions_spec_by_expr"); + } + + ThriftHiveMetastore_get_partitions_spec_by_expr_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partitions_spec_by_expr", bytes); + } + + ThriftHiveMetastore_get_partitions_spec_by_expr_result result; + try { + iface_->get_partitions_spec_by_expr(result.success, args.req); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partitions_spec_by_expr"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partitions_spec_by_expr", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partitions_spec_by_expr"); + } + + oprot->writeMessageBegin("get_partitions_spec_by_expr", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partitions_spec_by_expr", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_num_partitions_by_filter(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_num_partitions_by_filter", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_num_partitions_by_filter"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_num_partitions_by_filter"); + } + + ThriftHiveMetastore_get_num_partitions_by_filter_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_num_partitions_by_filter", bytes); + } + + ThriftHiveMetastore_get_num_partitions_by_filter_result result; + try { + result.success = iface_->get_num_partitions_by_filter(args.db_name, args.tbl_name, args.filter); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_num_partitions_by_filter"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_num_partitions_by_filter", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_num_partitions_by_filter"); + } + + oprot->writeMessageBegin("get_num_partitions_by_filter", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_num_partitions_by_filter", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partitions_by_names(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partitions_by_names", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partitions_by_names"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partitions_by_names"); + } + + ThriftHiveMetastore_get_partitions_by_names_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partitions_by_names", bytes); + } + + ThriftHiveMetastore_get_partitions_by_names_result result; + try { + iface_->get_partitions_by_names(result.success, args.db_name, args.tbl_name, args.names); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (InvalidObjectException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partitions_by_names"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partitions_by_names", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partitions_by_names"); + } + + oprot->writeMessageBegin("get_partitions_by_names", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partitions_by_names", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partitions_by_names_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partitions_by_names_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partitions_by_names_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partitions_by_names_req"); + } + + ThriftHiveMetastore_get_partitions_by_names_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partitions_by_names_req", bytes); + } + + ThriftHiveMetastore_get_partitions_by_names_req_result result; + try { + iface_->get_partitions_by_names_req(result.success, args.req); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (InvalidObjectException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partitions_by_names_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partitions_by_names_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partitions_by_names_req"); + } + + oprot->writeMessageBegin("get_partitions_by_names_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partitions_by_names_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_properties(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_properties", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_properties"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_properties"); + } + + ThriftHiveMetastore_get_properties_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_properties", bytes); + } + + ThriftHiveMetastore_get_properties_result result; + try { + iface_->get_properties(result.success, args.req); + result.__isset.success = true; + } catch (MetaException &e1) { + result.e1 = std::move(e1); + result.__isset.e1 = true; + } catch (NoSuchObjectException &e2) { + result.e2 = std::move(e2); + result.__isset.e2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_properties"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_properties", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_properties"); + } + + oprot->writeMessageBegin("get_properties", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_properties", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_set_properties(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.set_properties", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.set_properties"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.set_properties"); + } + + ThriftHiveMetastore_set_properties_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.set_properties", bytes); + } + + ThriftHiveMetastore_set_properties_result result; + try { + result.success = iface_->set_properties(args.req); + result.__isset.success = true; + } catch (MetaException &e1) { + result.e1 = std::move(e1); + result.__isset.e1 = true; + } catch (NoSuchObjectException &e2) { + result.e2 = std::move(e2); + result.__isset.e2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.set_properties"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("set_properties", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.set_properties"); + } + + oprot->writeMessageBegin("set_properties", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.set_properties", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_alter_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.alter_partition", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.alter_partition"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.alter_partition"); + } + + ThriftHiveMetastore_alter_partition_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.alter_partition", bytes); + } + + ThriftHiveMetastore_alter_partition_result result; + try { + iface_->alter_partition(args.db_name, args.tbl_name, args.new_part); + } catch (InvalidOperationException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.alter_partition"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("alter_partition", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.alter_partition"); + } + + oprot->writeMessageBegin("alter_partition", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.alter_partition", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_alter_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.alter_partitions", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.alter_partitions"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.alter_partitions"); + } + + ThriftHiveMetastore_alter_partitions_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.alter_partitions", bytes); + } + + ThriftHiveMetastore_alter_partitions_result result; + try { + iface_->alter_partitions(args.db_name, args.tbl_name, args.new_parts); + } catch (InvalidOperationException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.alter_partitions"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("alter_partitions", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.alter_partitions"); + } + + oprot->writeMessageBegin("alter_partitions", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.alter_partitions", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_alter_partitions_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.alter_partitions_with_environment_context", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.alter_partitions_with_environment_context"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.alter_partitions_with_environment_context"); + } + + ThriftHiveMetastore_alter_partitions_with_environment_context_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.alter_partitions_with_environment_context", bytes); + } + + ThriftHiveMetastore_alter_partitions_with_environment_context_result result; + try { + iface_->alter_partitions_with_environment_context(args.db_name, args.tbl_name, args.new_parts, args.environment_context); + } catch (InvalidOperationException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.alter_partitions_with_environment_context"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("alter_partitions_with_environment_context", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.alter_partitions_with_environment_context"); + } + + oprot->writeMessageBegin("alter_partitions_with_environment_context", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.alter_partitions_with_environment_context", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_alter_partitions_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.alter_partitions_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.alter_partitions_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.alter_partitions_req"); + } + + ThriftHiveMetastore_alter_partitions_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.alter_partitions_req", bytes); + } + + ThriftHiveMetastore_alter_partitions_req_result result; + try { + iface_->alter_partitions_req(result.success, args.req); + result.__isset.success = true; + } catch (InvalidOperationException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.alter_partitions_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("alter_partitions_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.alter_partitions_req"); + } + + oprot->writeMessageBegin("alter_partitions_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.alter_partitions_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_alter_partition_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.alter_partition_with_environment_context", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.alter_partition_with_environment_context"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.alter_partition_with_environment_context"); + } + + ThriftHiveMetastore_alter_partition_with_environment_context_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.alter_partition_with_environment_context", bytes); + } + + ThriftHiveMetastore_alter_partition_with_environment_context_result result; + try { + iface_->alter_partition_with_environment_context(args.db_name, args.tbl_name, args.new_part, args.environment_context); + } catch (InvalidOperationException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.alter_partition_with_environment_context"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("alter_partition_with_environment_context", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.alter_partition_with_environment_context"); + } + + oprot->writeMessageBegin("alter_partition_with_environment_context", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.alter_partition_with_environment_context", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_rename_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.rename_partition", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.rename_partition"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.rename_partition"); + } + + ThriftHiveMetastore_rename_partition_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.rename_partition", bytes); + } + + ThriftHiveMetastore_rename_partition_result result; + try { + iface_->rename_partition(args.db_name, args.tbl_name, args.part_vals, args.new_part); + } catch (InvalidOperationException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.rename_partition"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("rename_partition", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.rename_partition"); + } + + oprot->writeMessageBegin("rename_partition", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.rename_partition", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_rename_partition_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.rename_partition_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.rename_partition_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.rename_partition_req"); + } + + ThriftHiveMetastore_rename_partition_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.rename_partition_req", bytes); + } + + ThriftHiveMetastore_rename_partition_req_result result; + try { + iface_->rename_partition_req(result.success, args.req); + result.__isset.success = true; + } catch (InvalidOperationException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.rename_partition_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("rename_partition_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.rename_partition_req"); + } + + oprot->writeMessageBegin("rename_partition_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.rename_partition_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_partition_name_has_valid_characters(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.partition_name_has_valid_characters", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.partition_name_has_valid_characters"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.partition_name_has_valid_characters"); + } + + ThriftHiveMetastore_partition_name_has_valid_characters_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.partition_name_has_valid_characters", bytes); + } + + ThriftHiveMetastore_partition_name_has_valid_characters_result result; + try { + result.success = iface_->partition_name_has_valid_characters(args.part_vals, args.throw_exception); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.partition_name_has_valid_characters"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("partition_name_has_valid_characters", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.partition_name_has_valid_characters"); + } + + oprot->writeMessageBegin("partition_name_has_valid_characters", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.partition_name_has_valid_characters", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_config_value(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_config_value", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_config_value"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_config_value"); + } + + ThriftHiveMetastore_get_config_value_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_config_value", bytes); + } + + ThriftHiveMetastore_get_config_value_result result; + try { + iface_->get_config_value(result.success, args.name, args.defaultValue); + result.__isset.success = true; + } catch (ConfigValSecurityException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_config_value"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_config_value", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_config_value"); + } + + oprot->writeMessageBegin("get_config_value", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_config_value", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_partition_name_to_vals(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.partition_name_to_vals", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.partition_name_to_vals"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.partition_name_to_vals"); + } + + ThriftHiveMetastore_partition_name_to_vals_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.partition_name_to_vals", bytes); + } + + ThriftHiveMetastore_partition_name_to_vals_result result; + try { + iface_->partition_name_to_vals(result.success, args.part_name); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.partition_name_to_vals"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("partition_name_to_vals", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.partition_name_to_vals"); + } + + oprot->writeMessageBegin("partition_name_to_vals", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.partition_name_to_vals", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_partition_name_to_spec(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.partition_name_to_spec", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.partition_name_to_spec"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.partition_name_to_spec"); + } + + ThriftHiveMetastore_partition_name_to_spec_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.partition_name_to_spec", bytes); + } + + ThriftHiveMetastore_partition_name_to_spec_result result; + try { + iface_->partition_name_to_spec(result.success, args.part_name); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.partition_name_to_spec"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("partition_name_to_spec", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.partition_name_to_spec"); + } + + oprot->writeMessageBegin("partition_name_to_spec", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.partition_name_to_spec", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_markPartitionForEvent(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.markPartitionForEvent", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.markPartitionForEvent"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.markPartitionForEvent"); + } + + ThriftHiveMetastore_markPartitionForEvent_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.markPartitionForEvent", bytes); + } + + ThriftHiveMetastore_markPartitionForEvent_result result; + try { + iface_->markPartitionForEvent(args.db_name, args.tbl_name, args.part_vals, args.eventType); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (UnknownDBException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (UnknownTableException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (UnknownPartitionException &o5) { + result.o5 = std::move(o5); + result.__isset.o5 = true; + } catch (InvalidPartitionException &o6) { + result.o6 = std::move(o6); + result.__isset.o6 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.markPartitionForEvent"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("markPartitionForEvent", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.markPartitionForEvent"); + } + + oprot->writeMessageBegin("markPartitionForEvent", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.markPartitionForEvent", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_isPartitionMarkedForEvent(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.isPartitionMarkedForEvent", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.isPartitionMarkedForEvent"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.isPartitionMarkedForEvent"); + } + + ThriftHiveMetastore_isPartitionMarkedForEvent_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.isPartitionMarkedForEvent", bytes); + } + + ThriftHiveMetastore_isPartitionMarkedForEvent_result result; + try { + result.success = iface_->isPartitionMarkedForEvent(args.db_name, args.tbl_name, args.part_vals, args.eventType); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (UnknownDBException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (UnknownTableException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (UnknownPartitionException &o5) { + result.o5 = std::move(o5); + result.__isset.o5 = true; + } catch (InvalidPartitionException &o6) { + result.o6 = std::move(o6); + result.__isset.o6 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.isPartitionMarkedForEvent"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("isPartitionMarkedForEvent", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.isPartitionMarkedForEvent"); + } + + oprot->writeMessageBegin("isPartitionMarkedForEvent", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.isPartitionMarkedForEvent", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_primary_keys(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_primary_keys", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_primary_keys"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_primary_keys"); + } + + ThriftHiveMetastore_get_primary_keys_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_primary_keys", bytes); + } + + ThriftHiveMetastore_get_primary_keys_result result; + try { + iface_->get_primary_keys(result.success, args.request); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_primary_keys"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_primary_keys", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_primary_keys"); + } + + oprot->writeMessageBegin("get_primary_keys", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_primary_keys", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_foreign_keys(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_foreign_keys", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_foreign_keys"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_foreign_keys"); + } + + ThriftHiveMetastore_get_foreign_keys_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_foreign_keys", bytes); + } + + ThriftHiveMetastore_get_foreign_keys_result result; + try { + iface_->get_foreign_keys(result.success, args.request); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_foreign_keys"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_foreign_keys", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_foreign_keys"); + } + + oprot->writeMessageBegin("get_foreign_keys", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_foreign_keys", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_unique_constraints(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_unique_constraints", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_unique_constraints"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_unique_constraints"); + } + + ThriftHiveMetastore_get_unique_constraints_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_unique_constraints", bytes); + } + + ThriftHiveMetastore_get_unique_constraints_result result; + try { + iface_->get_unique_constraints(result.success, args.request); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_unique_constraints"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_unique_constraints", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_unique_constraints"); + } + + oprot->writeMessageBegin("get_unique_constraints", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_unique_constraints", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_not_null_constraints(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_not_null_constraints", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_not_null_constraints"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_not_null_constraints"); + } + + ThriftHiveMetastore_get_not_null_constraints_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_not_null_constraints", bytes); + } + + ThriftHiveMetastore_get_not_null_constraints_result result; + try { + iface_->get_not_null_constraints(result.success, args.request); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_not_null_constraints"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_not_null_constraints", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_not_null_constraints"); + } + + oprot->writeMessageBegin("get_not_null_constraints", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_not_null_constraints", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_default_constraints(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_default_constraints", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_default_constraints"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_default_constraints"); + } + + ThriftHiveMetastore_get_default_constraints_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_default_constraints", bytes); + } + + ThriftHiveMetastore_get_default_constraints_result result; + try { + iface_->get_default_constraints(result.success, args.request); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_default_constraints"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_default_constraints", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_default_constraints"); + } + + oprot->writeMessageBegin("get_default_constraints", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_default_constraints", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_check_constraints(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_check_constraints", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_check_constraints"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_check_constraints"); + } + + ThriftHiveMetastore_get_check_constraints_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_check_constraints", bytes); + } + + ThriftHiveMetastore_get_check_constraints_result result; + try { + iface_->get_check_constraints(result.success, args.request); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_check_constraints"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_check_constraints", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_check_constraints"); + } + + oprot->writeMessageBegin("get_check_constraints", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_check_constraints", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_all_table_constraints(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_all_table_constraints", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_all_table_constraints"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_all_table_constraints"); + } + + ThriftHiveMetastore_get_all_table_constraints_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_all_table_constraints", bytes); + } + + ThriftHiveMetastore_get_all_table_constraints_result result; + try { + iface_->get_all_table_constraints(result.success, args.request); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_all_table_constraints"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_all_table_constraints", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_all_table_constraints"); + } + + oprot->writeMessageBegin("get_all_table_constraints", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_all_table_constraints", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_update_table_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.update_table_column_statistics", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.update_table_column_statistics"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.update_table_column_statistics"); + } + + ThriftHiveMetastore_update_table_column_statistics_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.update_table_column_statistics", bytes); + } + + ThriftHiveMetastore_update_table_column_statistics_result result; + try { + result.success = iface_->update_table_column_statistics(args.stats_obj); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (InvalidInputException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.update_table_column_statistics"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("update_table_column_statistics", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.update_table_column_statistics"); + } + + oprot->writeMessageBegin("update_table_column_statistics", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.update_table_column_statistics", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_update_partition_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.update_partition_column_statistics", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.update_partition_column_statistics"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.update_partition_column_statistics"); + } + + ThriftHiveMetastore_update_partition_column_statistics_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.update_partition_column_statistics", bytes); + } + + ThriftHiveMetastore_update_partition_column_statistics_result result; + try { + result.success = iface_->update_partition_column_statistics(args.stats_obj); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (InvalidInputException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.update_partition_column_statistics"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("update_partition_column_statistics", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.update_partition_column_statistics"); + } + + oprot->writeMessageBegin("update_partition_column_statistics", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.update_partition_column_statistics", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_update_table_column_statistics_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.update_table_column_statistics_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.update_table_column_statistics_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.update_table_column_statistics_req"); + } + + ThriftHiveMetastore_update_table_column_statistics_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.update_table_column_statistics_req", bytes); + } + + ThriftHiveMetastore_update_table_column_statistics_req_result result; + try { + iface_->update_table_column_statistics_req(result.success, args.req); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (InvalidInputException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.update_table_column_statistics_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("update_table_column_statistics_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.update_table_column_statistics_req"); + } + + oprot->writeMessageBegin("update_table_column_statistics_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.update_table_column_statistics_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_update_partition_column_statistics_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.update_partition_column_statistics_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.update_partition_column_statistics_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.update_partition_column_statistics_req"); + } + + ThriftHiveMetastore_update_partition_column_statistics_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.update_partition_column_statistics_req", bytes); + } + + ThriftHiveMetastore_update_partition_column_statistics_req_result result; + try { + iface_->update_partition_column_statistics_req(result.success, args.req); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (InvalidInputException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.update_partition_column_statistics_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("update_partition_column_statistics_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.update_partition_column_statistics_req"); + } + + oprot->writeMessageBegin("update_partition_column_statistics_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.update_partition_column_statistics_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_update_transaction_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.update_transaction_statistics", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.update_transaction_statistics"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.update_transaction_statistics"); + } + + ThriftHiveMetastore_update_transaction_statistics_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.update_transaction_statistics", bytes); + } + + ThriftHiveMetastore_update_transaction_statistics_result result; + try { + iface_->update_transaction_statistics(args.req); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.update_transaction_statistics"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("update_transaction_statistics", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.update_transaction_statistics"); + } + + oprot->writeMessageBegin("update_transaction_statistics", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.update_transaction_statistics", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_table_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_table_column_statistics", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_table_column_statistics"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_table_column_statistics"); + } + + ThriftHiveMetastore_get_table_column_statistics_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_table_column_statistics", bytes); + } + + ThriftHiveMetastore_get_table_column_statistics_result result; + try { + iface_->get_table_column_statistics(result.success, args.db_name, args.tbl_name, args.col_name); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (InvalidInputException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (InvalidObjectException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_table_column_statistics"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_table_column_statistics", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_table_column_statistics"); + } + + oprot->writeMessageBegin("get_table_column_statistics", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_table_column_statistics", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partition_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partition_column_statistics", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partition_column_statistics"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partition_column_statistics"); + } + + ThriftHiveMetastore_get_partition_column_statistics_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partition_column_statistics", bytes); + } + + ThriftHiveMetastore_get_partition_column_statistics_result result; + try { + iface_->get_partition_column_statistics(result.success, args.db_name, args.tbl_name, args.part_name, args.col_name); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (InvalidInputException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (InvalidObjectException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partition_column_statistics"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partition_column_statistics", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partition_column_statistics"); + } + + oprot->writeMessageBegin("get_partition_column_statistics", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partition_column_statistics", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_table_statistics_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_table_statistics_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_table_statistics_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_table_statistics_req"); + } + + ThriftHiveMetastore_get_table_statistics_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_table_statistics_req", bytes); + } + + ThriftHiveMetastore_get_table_statistics_req_result result; + try { + iface_->get_table_statistics_req(result.success, args.request); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_table_statistics_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_table_statistics_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_table_statistics_req"); + } + + oprot->writeMessageBegin("get_table_statistics_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_table_statistics_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partitions_statistics_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partitions_statistics_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partitions_statistics_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partitions_statistics_req"); + } + + ThriftHiveMetastore_get_partitions_statistics_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partitions_statistics_req", bytes); + } + + ThriftHiveMetastore_get_partitions_statistics_req_result result; + try { + iface_->get_partitions_statistics_req(result.success, args.request); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partitions_statistics_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partitions_statistics_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partitions_statistics_req"); + } + + oprot->writeMessageBegin("get_partitions_statistics_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partitions_statistics_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_aggr_stats_for(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_aggr_stats_for", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_aggr_stats_for"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_aggr_stats_for"); + } + + ThriftHiveMetastore_get_aggr_stats_for_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_aggr_stats_for", bytes); + } + + ThriftHiveMetastore_get_aggr_stats_for_result result; + try { + iface_->get_aggr_stats_for(result.success, args.request); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_aggr_stats_for"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_aggr_stats_for", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_aggr_stats_for"); + } + + oprot->writeMessageBegin("get_aggr_stats_for", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_aggr_stats_for", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_set_aggr_stats_for(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.set_aggr_stats_for", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.set_aggr_stats_for"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.set_aggr_stats_for"); + } + + ThriftHiveMetastore_set_aggr_stats_for_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.set_aggr_stats_for", bytes); + } + + ThriftHiveMetastore_set_aggr_stats_for_result result; + try { + result.success = iface_->set_aggr_stats_for(args.request); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (InvalidInputException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.set_aggr_stats_for"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("set_aggr_stats_for", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.set_aggr_stats_for"); + } + + oprot->writeMessageBegin("set_aggr_stats_for", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.set_aggr_stats_for", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_delete_partition_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.delete_partition_column_statistics", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.delete_partition_column_statistics"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.delete_partition_column_statistics"); + } + + ThriftHiveMetastore_delete_partition_column_statistics_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.delete_partition_column_statistics", bytes); + } + + ThriftHiveMetastore_delete_partition_column_statistics_result result; + try { + result.success = iface_->delete_partition_column_statistics(args.db_name, args.tbl_name, args.part_name, args.col_name, args.engine); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (InvalidObjectException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (InvalidInputException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.delete_partition_column_statistics"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("delete_partition_column_statistics", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.delete_partition_column_statistics"); + } + + oprot->writeMessageBegin("delete_partition_column_statistics", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.delete_partition_column_statistics", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_delete_table_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.delete_table_column_statistics", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.delete_table_column_statistics"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.delete_table_column_statistics"); + } + + ThriftHiveMetastore_delete_table_column_statistics_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.delete_table_column_statistics", bytes); + } + + ThriftHiveMetastore_delete_table_column_statistics_result result; + try { + result.success = iface_->delete_table_column_statistics(args.db_name, args.tbl_name, args.col_name, args.engine); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (InvalidObjectException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (InvalidInputException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.delete_table_column_statistics"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("delete_table_column_statistics", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.delete_table_column_statistics"); + } + + oprot->writeMessageBegin("delete_table_column_statistics", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.delete_table_column_statistics", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_create_function(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.create_function", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.create_function"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.create_function"); + } + + ThriftHiveMetastore_create_function_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.create_function", bytes); + } + + ThriftHiveMetastore_create_function_result result; + try { + iface_->create_function(args.func); + } catch (AlreadyExistsException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (NoSuchObjectException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.create_function"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("create_function", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.create_function"); + } + + oprot->writeMessageBegin("create_function", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.create_function", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_function(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_function", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_function"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_function"); + } + + ThriftHiveMetastore_drop_function_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_function", bytes); + } + + ThriftHiveMetastore_drop_function_result result; + try { + iface_->drop_function(args.dbName, args.funcName); + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_function"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_function", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_function"); + } + + oprot->writeMessageBegin("drop_function", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_function", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_alter_function(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.alter_function", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.alter_function"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.alter_function"); + } + + ThriftHiveMetastore_alter_function_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.alter_function", bytes); + } + + ThriftHiveMetastore_alter_function_result result; + try { + iface_->alter_function(args.dbName, args.funcName, args.newFunc); + } catch (InvalidOperationException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.alter_function"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("alter_function", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.alter_function"); + } + + oprot->writeMessageBegin("alter_function", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.alter_function", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_functions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_functions", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_functions"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_functions"); + } + + ThriftHiveMetastore_get_functions_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_functions", bytes); + } + + ThriftHiveMetastore_get_functions_result result; + try { + iface_->get_functions(result.success, args.dbName, args.pattern); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_functions"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_functions", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_functions"); + } + + oprot->writeMessageBegin("get_functions", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_functions", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_function(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_function", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_function"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_function"); + } + + ThriftHiveMetastore_get_function_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_function", bytes); + } + + ThriftHiveMetastore_get_function_result result; + try { + iface_->get_function(result.success, args.dbName, args.funcName); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_function"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_function", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_function"); + } + + oprot->writeMessageBegin("get_function", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_function", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_all_functions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_all_functions", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_all_functions"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_all_functions"); + } + + ThriftHiveMetastore_get_all_functions_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_all_functions", bytes); + } + + ThriftHiveMetastore_get_all_functions_result result; + try { + iface_->get_all_functions(result.success); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_all_functions"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_all_functions", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_all_functions"); + } + + oprot->writeMessageBegin("get_all_functions", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_all_functions", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_create_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.create_role", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.create_role"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.create_role"); + } + + ThriftHiveMetastore_create_role_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.create_role", bytes); + } + + ThriftHiveMetastore_create_role_result result; + try { + result.success = iface_->create_role(args.role); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.create_role"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("create_role", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.create_role"); + } + + oprot->writeMessageBegin("create_role", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.create_role", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_role", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_role"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_role"); + } + + ThriftHiveMetastore_drop_role_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_role", bytes); + } + + ThriftHiveMetastore_drop_role_result result; + try { + result.success = iface_->drop_role(args.role_name); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_role"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_role", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_role"); + } + + oprot->writeMessageBegin("drop_role", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_role", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_role_names(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_role_names", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_role_names"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_role_names"); + } + + ThriftHiveMetastore_get_role_names_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_role_names", bytes); + } + + ThriftHiveMetastore_get_role_names_result result; + try { + iface_->get_role_names(result.success); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_role_names"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_role_names", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_role_names"); + } + + oprot->writeMessageBegin("get_role_names", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_role_names", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_grant_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.grant_role", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.grant_role"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.grant_role"); + } + + ThriftHiveMetastore_grant_role_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.grant_role", bytes); + } + + ThriftHiveMetastore_grant_role_result result; + try { + result.success = iface_->grant_role(args.role_name, args.principal_name, args.principal_type, args.grantor, args.grantorType, args.grant_option); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.grant_role"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("grant_role", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.grant_role"); + } + + oprot->writeMessageBegin("grant_role", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.grant_role", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_revoke_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.revoke_role", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.revoke_role"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.revoke_role"); + } + + ThriftHiveMetastore_revoke_role_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.revoke_role", bytes); + } + + ThriftHiveMetastore_revoke_role_result result; + try { + result.success = iface_->revoke_role(args.role_name, args.principal_name, args.principal_type); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.revoke_role"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("revoke_role", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.revoke_role"); + } + + oprot->writeMessageBegin("revoke_role", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.revoke_role", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_list_roles(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.list_roles", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.list_roles"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.list_roles"); + } + + ThriftHiveMetastore_list_roles_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.list_roles", bytes); + } + + ThriftHiveMetastore_list_roles_result result; + try { + iface_->list_roles(result.success, args.principal_name, args.principal_type); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.list_roles"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("list_roles", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.list_roles"); + } + + oprot->writeMessageBegin("list_roles", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.list_roles", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_grant_revoke_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.grant_revoke_role", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.grant_revoke_role"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.grant_revoke_role"); + } + + ThriftHiveMetastore_grant_revoke_role_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.grant_revoke_role", bytes); + } + + ThriftHiveMetastore_grant_revoke_role_result result; + try { + iface_->grant_revoke_role(result.success, args.request); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.grant_revoke_role"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("grant_revoke_role", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.grant_revoke_role"); + } + + oprot->writeMessageBegin("grant_revoke_role", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.grant_revoke_role", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_principals_in_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_principals_in_role", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_principals_in_role"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_principals_in_role"); + } + + ThriftHiveMetastore_get_principals_in_role_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_principals_in_role", bytes); + } + + ThriftHiveMetastore_get_principals_in_role_result result; + try { + iface_->get_principals_in_role(result.success, args.request); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_principals_in_role"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_principals_in_role", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_principals_in_role"); + } + + oprot->writeMessageBegin("get_principals_in_role", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_principals_in_role", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_role_grants_for_principal(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_role_grants_for_principal", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_role_grants_for_principal"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_role_grants_for_principal"); + } + + ThriftHiveMetastore_get_role_grants_for_principal_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_role_grants_for_principal", bytes); + } + + ThriftHiveMetastore_get_role_grants_for_principal_result result; + try { + iface_->get_role_grants_for_principal(result.success, args.request); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_role_grants_for_principal"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_role_grants_for_principal", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_role_grants_for_principal"); + } + + oprot->writeMessageBegin("get_role_grants_for_principal", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_role_grants_for_principal", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_privilege_set(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_privilege_set", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_privilege_set"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_privilege_set"); + } + + ThriftHiveMetastore_get_privilege_set_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_privilege_set", bytes); + } + + ThriftHiveMetastore_get_privilege_set_result result; + try { + iface_->get_privilege_set(result.success, args.hiveObject, args.user_name, args.group_names); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_privilege_set"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_privilege_set", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_privilege_set"); + } + + oprot->writeMessageBegin("get_privilege_set", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_privilege_set", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_list_privileges(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.list_privileges", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.list_privileges"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.list_privileges"); + } + + ThriftHiveMetastore_list_privileges_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.list_privileges", bytes); + } + + ThriftHiveMetastore_list_privileges_result result; + try { + iface_->list_privileges(result.success, args.principal_name, args.principal_type, args.hiveObject); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.list_privileges"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("list_privileges", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.list_privileges"); + } + + oprot->writeMessageBegin("list_privileges", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.list_privileges", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_grant_privileges(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.grant_privileges", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.grant_privileges"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.grant_privileges"); + } + + ThriftHiveMetastore_grant_privileges_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.grant_privileges", bytes); + } + + ThriftHiveMetastore_grant_privileges_result result; + try { + result.success = iface_->grant_privileges(args.privileges); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.grant_privileges"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("grant_privileges", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.grant_privileges"); + } + + oprot->writeMessageBegin("grant_privileges", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.grant_privileges", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_revoke_privileges(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.revoke_privileges", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.revoke_privileges"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.revoke_privileges"); + } + + ThriftHiveMetastore_revoke_privileges_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.revoke_privileges", bytes); + } + + ThriftHiveMetastore_revoke_privileges_result result; + try { + result.success = iface_->revoke_privileges(args.privileges); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.revoke_privileges"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("revoke_privileges", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.revoke_privileges"); + } + + oprot->writeMessageBegin("revoke_privileges", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.revoke_privileges", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_grant_revoke_privileges(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.grant_revoke_privileges", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.grant_revoke_privileges"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.grant_revoke_privileges"); + } + + ThriftHiveMetastore_grant_revoke_privileges_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.grant_revoke_privileges", bytes); + } + + ThriftHiveMetastore_grant_revoke_privileges_result result; + try { + iface_->grant_revoke_privileges(result.success, args.request); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.grant_revoke_privileges"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("grant_revoke_privileges", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.grant_revoke_privileges"); + } + + oprot->writeMessageBegin("grant_revoke_privileges", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.grant_revoke_privileges", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_refresh_privileges(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.refresh_privileges", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.refresh_privileges"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.refresh_privileges"); + } + + ThriftHiveMetastore_refresh_privileges_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.refresh_privileges", bytes); + } + + ThriftHiveMetastore_refresh_privileges_result result; + try { + iface_->refresh_privileges(result.success, args.objToRefresh, args.authorizer, args.grantRequest); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.refresh_privileges"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("refresh_privileges", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.refresh_privileges"); + } + + oprot->writeMessageBegin("refresh_privileges", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.refresh_privileges", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_set_ugi(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.set_ugi", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.set_ugi"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.set_ugi"); + } + + ThriftHiveMetastore_set_ugi_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.set_ugi", bytes); + } + + ThriftHiveMetastore_set_ugi_result result; + try { + iface_->set_ugi(result.success, args.user_name, args.group_names); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.set_ugi"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("set_ugi", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.set_ugi"); + } + + oprot->writeMessageBegin("set_ugi", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.set_ugi", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_delegation_token(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_delegation_token", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_delegation_token"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_delegation_token"); + } + + ThriftHiveMetastore_get_delegation_token_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_delegation_token", bytes); + } + + ThriftHiveMetastore_get_delegation_token_result result; + try { + iface_->get_delegation_token(result.success, args.token_owner, args.renewer_kerberos_principal_name); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_delegation_token"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_delegation_token", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_delegation_token"); + } + + oprot->writeMessageBegin("get_delegation_token", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_delegation_token", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_renew_delegation_token(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.renew_delegation_token", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.renew_delegation_token"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.renew_delegation_token"); + } + + ThriftHiveMetastore_renew_delegation_token_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.renew_delegation_token", bytes); + } + + ThriftHiveMetastore_renew_delegation_token_result result; + try { + result.success = iface_->renew_delegation_token(args.token_str_form); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.renew_delegation_token"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("renew_delegation_token", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.renew_delegation_token"); + } + + oprot->writeMessageBegin("renew_delegation_token", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.renew_delegation_token", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_cancel_delegation_token(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.cancel_delegation_token", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.cancel_delegation_token"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.cancel_delegation_token"); + } + + ThriftHiveMetastore_cancel_delegation_token_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.cancel_delegation_token", bytes); + } + + ThriftHiveMetastore_cancel_delegation_token_result result; + try { + iface_->cancel_delegation_token(args.token_str_form); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.cancel_delegation_token"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("cancel_delegation_token", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.cancel_delegation_token"); + } + + oprot->writeMessageBegin("cancel_delegation_token", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.cancel_delegation_token", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_add_token(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.add_token", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.add_token"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.add_token"); + } + + ThriftHiveMetastore_add_token_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.add_token", bytes); + } + + ThriftHiveMetastore_add_token_result result; + try { + result.success = iface_->add_token(args.token_identifier, args.delegation_token); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.add_token"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("add_token", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.add_token"); + } + + oprot->writeMessageBegin("add_token", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.add_token", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_remove_token(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.remove_token", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.remove_token"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.remove_token"); + } + + ThriftHiveMetastore_remove_token_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.remove_token", bytes); + } + + ThriftHiveMetastore_remove_token_result result; + try { + result.success = iface_->remove_token(args.token_identifier); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.remove_token"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("remove_token", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.remove_token"); + } + + oprot->writeMessageBegin("remove_token", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.remove_token", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_token(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_token", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_token"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_token"); + } + + ThriftHiveMetastore_get_token_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_token", bytes); + } + + ThriftHiveMetastore_get_token_result result; + try { + iface_->get_token(result.success, args.token_identifier); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_token"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_token", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_token"); + } + + oprot->writeMessageBegin("get_token", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_token", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_all_token_identifiers(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_all_token_identifiers", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_all_token_identifiers"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_all_token_identifiers"); + } + + ThriftHiveMetastore_get_all_token_identifiers_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_all_token_identifiers", bytes); + } + + ThriftHiveMetastore_get_all_token_identifiers_result result; + try { + iface_->get_all_token_identifiers(result.success); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_all_token_identifiers"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_all_token_identifiers", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_all_token_identifiers"); + } + + oprot->writeMessageBegin("get_all_token_identifiers", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_all_token_identifiers", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_add_master_key(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.add_master_key", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.add_master_key"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.add_master_key"); + } + + ThriftHiveMetastore_add_master_key_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.add_master_key", bytes); + } + + ThriftHiveMetastore_add_master_key_result result; + try { + result.success = iface_->add_master_key(args.key); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.add_master_key"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("add_master_key", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.add_master_key"); + } + + oprot->writeMessageBegin("add_master_key", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.add_master_key", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_update_master_key(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.update_master_key", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.update_master_key"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.update_master_key"); + } + + ThriftHiveMetastore_update_master_key_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.update_master_key", bytes); + } + + ThriftHiveMetastore_update_master_key_result result; + try { + iface_->update_master_key(args.seq_number, args.key); + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.update_master_key"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("update_master_key", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.update_master_key"); + } + + oprot->writeMessageBegin("update_master_key", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.update_master_key", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_remove_master_key(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.remove_master_key", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.remove_master_key"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.remove_master_key"); + } + + ThriftHiveMetastore_remove_master_key_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.remove_master_key", bytes); + } + + ThriftHiveMetastore_remove_master_key_result result; + try { + result.success = iface_->remove_master_key(args.key_seq); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.remove_master_key"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("remove_master_key", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.remove_master_key"); + } + + oprot->writeMessageBegin("remove_master_key", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.remove_master_key", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_master_keys(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_master_keys", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_master_keys"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_master_keys"); + } + + ThriftHiveMetastore_get_master_keys_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_master_keys", bytes); + } + + ThriftHiveMetastore_get_master_keys_result result; + try { + iface_->get_master_keys(result.success); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_master_keys"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_master_keys", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_master_keys"); + } + + oprot->writeMessageBegin("get_master_keys", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_master_keys", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_open_txns(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_open_txns", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_open_txns"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_open_txns"); + } + + ThriftHiveMetastore_get_open_txns_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_open_txns", bytes); + } + + ThriftHiveMetastore_get_open_txns_result result; + try { + iface_->get_open_txns(result.success); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_open_txns"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_open_txns", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_open_txns"); + } + + oprot->writeMessageBegin("get_open_txns", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_open_txns", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_open_txns_info(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_open_txns_info", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_open_txns_info"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_open_txns_info"); + } + + ThriftHiveMetastore_get_open_txns_info_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_open_txns_info", bytes); + } + + ThriftHiveMetastore_get_open_txns_info_result result; + try { + iface_->get_open_txns_info(result.success); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_open_txns_info"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_open_txns_info", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_open_txns_info"); + } + + oprot->writeMessageBegin("get_open_txns_info", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_open_txns_info", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_open_txns(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.open_txns", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.open_txns"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.open_txns"); + } + + ThriftHiveMetastore_open_txns_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.open_txns", bytes); + } + + ThriftHiveMetastore_open_txns_result result; + try { + iface_->open_txns(result.success, args.rqst); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.open_txns"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("open_txns", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.open_txns"); + } + + oprot->writeMessageBegin("open_txns", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.open_txns", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_abort_txn(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.abort_txn", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.abort_txn"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.abort_txn"); + } + + ThriftHiveMetastore_abort_txn_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.abort_txn", bytes); + } + + ThriftHiveMetastore_abort_txn_result result; + try { + iface_->abort_txn(args.rqst); + } catch (NoSuchTxnException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.abort_txn"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("abort_txn", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.abort_txn"); + } + + oprot->writeMessageBegin("abort_txn", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.abort_txn", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_abort_txns(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.abort_txns", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.abort_txns"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.abort_txns"); + } + + ThriftHiveMetastore_abort_txns_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.abort_txns", bytes); + } + + ThriftHiveMetastore_abort_txns_result result; + try { + iface_->abort_txns(args.rqst); + } catch (NoSuchTxnException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.abort_txns"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("abort_txns", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.abort_txns"); + } + + oprot->writeMessageBegin("abort_txns", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.abort_txns", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_commit_txn(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.commit_txn", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.commit_txn"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.commit_txn"); + } + + ThriftHiveMetastore_commit_txn_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.commit_txn", bytes); + } + + ThriftHiveMetastore_commit_txn_result result; + try { + iface_->commit_txn(args.rqst); + } catch (NoSuchTxnException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (TxnAbortedException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.commit_txn"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("commit_txn", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.commit_txn"); + } + + oprot->writeMessageBegin("commit_txn", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.commit_txn", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_latest_txnid_in_conflict(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_latest_txnid_in_conflict", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_latest_txnid_in_conflict"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_latest_txnid_in_conflict"); + } + + ThriftHiveMetastore_get_latest_txnid_in_conflict_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_latest_txnid_in_conflict", bytes); + } + + ThriftHiveMetastore_get_latest_txnid_in_conflict_result result; + try { + result.success = iface_->get_latest_txnid_in_conflict(args.txnId); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_latest_txnid_in_conflict"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_latest_txnid_in_conflict", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_latest_txnid_in_conflict"); + } + + oprot->writeMessageBegin("get_latest_txnid_in_conflict", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_latest_txnid_in_conflict", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_repl_tbl_writeid_state(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.repl_tbl_writeid_state", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.repl_tbl_writeid_state"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.repl_tbl_writeid_state"); + } + + ThriftHiveMetastore_repl_tbl_writeid_state_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.repl_tbl_writeid_state", bytes); + } + + ThriftHiveMetastore_repl_tbl_writeid_state_result result; + try { + iface_->repl_tbl_writeid_state(args.rqst); + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.repl_tbl_writeid_state"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("repl_tbl_writeid_state", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.repl_tbl_writeid_state"); + } + + oprot->writeMessageBegin("repl_tbl_writeid_state", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.repl_tbl_writeid_state", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_valid_write_ids(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_valid_write_ids", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_valid_write_ids"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_valid_write_ids"); + } + + ThriftHiveMetastore_get_valid_write_ids_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_valid_write_ids", bytes); + } + + ThriftHiveMetastore_get_valid_write_ids_result result; + try { + iface_->get_valid_write_ids(result.success, args.rqst); + result.__isset.success = true; + } catch (NoSuchTxnException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_valid_write_ids"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_valid_write_ids", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_valid_write_ids"); + } + + oprot->writeMessageBegin("get_valid_write_ids", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_valid_write_ids", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_add_write_ids_to_min_history(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.add_write_ids_to_min_history", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.add_write_ids_to_min_history"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.add_write_ids_to_min_history"); + } + + ThriftHiveMetastore_add_write_ids_to_min_history_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.add_write_ids_to_min_history", bytes); + } + + ThriftHiveMetastore_add_write_ids_to_min_history_result result; + try { + iface_->add_write_ids_to_min_history(args.txnId, args.writeIds); + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.add_write_ids_to_min_history"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("add_write_ids_to_min_history", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.add_write_ids_to_min_history"); + } + + oprot->writeMessageBegin("add_write_ids_to_min_history", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.add_write_ids_to_min_history", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_allocate_table_write_ids(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.allocate_table_write_ids", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.allocate_table_write_ids"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.allocate_table_write_ids"); + } + + ThriftHiveMetastore_allocate_table_write_ids_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.allocate_table_write_ids", bytes); + } + + ThriftHiveMetastore_allocate_table_write_ids_result result; + try { + iface_->allocate_table_write_ids(result.success, args.rqst); + result.__isset.success = true; + } catch (NoSuchTxnException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (TxnAbortedException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.allocate_table_write_ids"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("allocate_table_write_ids", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.allocate_table_write_ids"); + } + + oprot->writeMessageBegin("allocate_table_write_ids", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.allocate_table_write_ids", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_max_allocated_table_write_id(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_max_allocated_table_write_id", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_max_allocated_table_write_id"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_max_allocated_table_write_id"); + } + + ThriftHiveMetastore_get_max_allocated_table_write_id_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_max_allocated_table_write_id", bytes); + } + + ThriftHiveMetastore_get_max_allocated_table_write_id_result result; + try { + iface_->get_max_allocated_table_write_id(result.success, args.rqst); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_max_allocated_table_write_id"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_max_allocated_table_write_id", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_max_allocated_table_write_id"); + } + + oprot->writeMessageBegin("get_max_allocated_table_write_id", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_max_allocated_table_write_id", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_seed_write_id(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.seed_write_id", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.seed_write_id"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.seed_write_id"); + } + + ThriftHiveMetastore_seed_write_id_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.seed_write_id", bytes); + } + + ThriftHiveMetastore_seed_write_id_result result; + try { + iface_->seed_write_id(args.rqst); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.seed_write_id"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("seed_write_id", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.seed_write_id"); + } + + oprot->writeMessageBegin("seed_write_id", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.seed_write_id", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_seed_txn_id(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.seed_txn_id", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.seed_txn_id"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.seed_txn_id"); + } + + ThriftHiveMetastore_seed_txn_id_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.seed_txn_id", bytes); + } + + ThriftHiveMetastore_seed_txn_id_result result; + try { + iface_->seed_txn_id(args.rqst); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.seed_txn_id"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("seed_txn_id", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.seed_txn_id"); + } + + oprot->writeMessageBegin("seed_txn_id", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.seed_txn_id", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_lock(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.lock", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.lock"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.lock"); + } + + ThriftHiveMetastore_lock_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.lock", bytes); + } + + ThriftHiveMetastore_lock_result result; + try { + iface_->lock(result.success, args.rqst); + result.__isset.success = true; + } catch (NoSuchTxnException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (TxnAbortedException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.lock"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("lock", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.lock"); + } + + oprot->writeMessageBegin("lock", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.lock", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_check_lock(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.check_lock", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.check_lock"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.check_lock"); + } + + ThriftHiveMetastore_check_lock_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.check_lock", bytes); + } + + ThriftHiveMetastore_check_lock_result result; + try { + iface_->check_lock(result.success, args.rqst); + result.__isset.success = true; + } catch (NoSuchTxnException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (TxnAbortedException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (NoSuchLockException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.check_lock"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("check_lock", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.check_lock"); + } + + oprot->writeMessageBegin("check_lock", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.check_lock", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_unlock(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.unlock", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.unlock"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.unlock"); + } + + ThriftHiveMetastore_unlock_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.unlock", bytes); + } + + ThriftHiveMetastore_unlock_result result; + try { + iface_->unlock(args.rqst); + } catch (NoSuchLockException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (TxnOpenException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.unlock"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("unlock", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.unlock"); + } + + oprot->writeMessageBegin("unlock", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.unlock", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_show_locks(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.show_locks", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.show_locks"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.show_locks"); + } + + ThriftHiveMetastore_show_locks_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.show_locks", bytes); + } + + ThriftHiveMetastore_show_locks_result result; + try { + iface_->show_locks(result.success, args.rqst); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.show_locks"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("show_locks", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.show_locks"); + } + + oprot->writeMessageBegin("show_locks", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.show_locks", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_heartbeat(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.heartbeat", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.heartbeat"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.heartbeat"); + } + + ThriftHiveMetastore_heartbeat_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.heartbeat", bytes); + } + + ThriftHiveMetastore_heartbeat_result result; + try { + iface_->heartbeat(args.ids); + } catch (NoSuchLockException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchTxnException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (TxnAbortedException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.heartbeat"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("heartbeat", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.heartbeat"); + } + + oprot->writeMessageBegin("heartbeat", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.heartbeat", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_heartbeat_txn_range(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.heartbeat_txn_range", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.heartbeat_txn_range"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.heartbeat_txn_range"); + } + + ThriftHiveMetastore_heartbeat_txn_range_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.heartbeat_txn_range", bytes); + } + + ThriftHiveMetastore_heartbeat_txn_range_result result; + try { + iface_->heartbeat_txn_range(result.success, args.txns); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.heartbeat_txn_range"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("heartbeat_txn_range", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.heartbeat_txn_range"); + } + + oprot->writeMessageBegin("heartbeat_txn_range", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.heartbeat_txn_range", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_compact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.compact", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.compact"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.compact"); + } + + ThriftHiveMetastore_compact_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.compact", bytes); + } + + ThriftHiveMetastore_compact_result result; + try { + iface_->compact(args.rqst); + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.compact"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("compact", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.compact"); + } + + oprot->writeMessageBegin("compact", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.compact", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_compact2(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.compact2", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.compact2"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.compact2"); + } + + ThriftHiveMetastore_compact2_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.compact2", bytes); + } + + ThriftHiveMetastore_compact2_result result; + try { + iface_->compact2(result.success, args.rqst); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.compact2"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("compact2", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.compact2"); + } + + oprot->writeMessageBegin("compact2", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.compact2", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_show_compact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.show_compact", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.show_compact"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.show_compact"); + } + + ThriftHiveMetastore_show_compact_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.show_compact", bytes); + } + + ThriftHiveMetastore_show_compact_result result; + try { + iface_->show_compact(result.success, args.rqst); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.show_compact"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("show_compact", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.show_compact"); + } + + oprot->writeMessageBegin("show_compact", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.show_compact", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_submit_for_cleanup(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.submit_for_cleanup", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.submit_for_cleanup"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.submit_for_cleanup"); + } + + ThriftHiveMetastore_submit_for_cleanup_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.submit_for_cleanup", bytes); + } + + ThriftHiveMetastore_submit_for_cleanup_result result; + try { + result.success = iface_->submit_for_cleanup(args.o1, args.o2, args.o3); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.submit_for_cleanup"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("submit_for_cleanup", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.submit_for_cleanup"); + } + + oprot->writeMessageBegin("submit_for_cleanup", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.submit_for_cleanup", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_add_dynamic_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.add_dynamic_partitions", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.add_dynamic_partitions"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.add_dynamic_partitions"); + } + + ThriftHiveMetastore_add_dynamic_partitions_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.add_dynamic_partitions", bytes); + } + + ThriftHiveMetastore_add_dynamic_partitions_result result; + try { + iface_->add_dynamic_partitions(args.rqst); + } catch (NoSuchTxnException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (TxnAbortedException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.add_dynamic_partitions"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("add_dynamic_partitions", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.add_dynamic_partitions"); + } + + oprot->writeMessageBegin("add_dynamic_partitions", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.add_dynamic_partitions", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_find_next_compact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.find_next_compact", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.find_next_compact"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.find_next_compact"); + } + + ThriftHiveMetastore_find_next_compact_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.find_next_compact", bytes); + } + + ThriftHiveMetastore_find_next_compact_result result; + try { + iface_->find_next_compact(result.success, args.workerId); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.find_next_compact"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("find_next_compact", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.find_next_compact"); + } + + oprot->writeMessageBegin("find_next_compact", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.find_next_compact", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_find_next_compact2(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.find_next_compact2", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.find_next_compact2"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.find_next_compact2"); + } + + ThriftHiveMetastore_find_next_compact2_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.find_next_compact2", bytes); + } + + ThriftHiveMetastore_find_next_compact2_result result; + try { + iface_->find_next_compact2(result.success, args.rqst); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.find_next_compact2"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("find_next_compact2", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.find_next_compact2"); + } + + oprot->writeMessageBegin("find_next_compact2", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.find_next_compact2", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_update_compactor_state(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.update_compactor_state", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.update_compactor_state"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.update_compactor_state"); + } + + ThriftHiveMetastore_update_compactor_state_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.update_compactor_state", bytes); + } + + ThriftHiveMetastore_update_compactor_state_result result; + try { + iface_->update_compactor_state(args.cr, args.txn_id); + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.update_compactor_state"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("update_compactor_state", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.update_compactor_state"); + } + + oprot->writeMessageBegin("update_compactor_state", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.update_compactor_state", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_find_columns_with_stats(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.find_columns_with_stats", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.find_columns_with_stats"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.find_columns_with_stats"); + } + + ThriftHiveMetastore_find_columns_with_stats_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.find_columns_with_stats", bytes); + } + + ThriftHiveMetastore_find_columns_with_stats_result result; + try { + iface_->find_columns_with_stats(result.success, args.cr); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.find_columns_with_stats"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("find_columns_with_stats", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.find_columns_with_stats"); + } + + oprot->writeMessageBegin("find_columns_with_stats", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.find_columns_with_stats", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_mark_cleaned(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.mark_cleaned", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.mark_cleaned"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.mark_cleaned"); + } + + ThriftHiveMetastore_mark_cleaned_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.mark_cleaned", bytes); + } + + ThriftHiveMetastore_mark_cleaned_result result; + try { + iface_->mark_cleaned(args.cr); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.mark_cleaned"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("mark_cleaned", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.mark_cleaned"); + } + + oprot->writeMessageBegin("mark_cleaned", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.mark_cleaned", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_mark_compacted(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.mark_compacted", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.mark_compacted"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.mark_compacted"); + } + + ThriftHiveMetastore_mark_compacted_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.mark_compacted", bytes); + } + + ThriftHiveMetastore_mark_compacted_result result; + try { + iface_->mark_compacted(args.cr); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.mark_compacted"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("mark_compacted", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.mark_compacted"); + } + + oprot->writeMessageBegin("mark_compacted", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.mark_compacted", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_mark_failed(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.mark_failed", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.mark_failed"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.mark_failed"); + } + + ThriftHiveMetastore_mark_failed_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.mark_failed", bytes); + } + + ThriftHiveMetastore_mark_failed_result result; + try { + iface_->mark_failed(args.cr); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.mark_failed"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("mark_failed", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.mark_failed"); + } + + oprot->writeMessageBegin("mark_failed", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.mark_failed", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_mark_refused(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.mark_refused", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.mark_refused"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.mark_refused"); + } + + ThriftHiveMetastore_mark_refused_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.mark_refused", bytes); + } + + ThriftHiveMetastore_mark_refused_result result; + try { + iface_->mark_refused(args.cr); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.mark_refused"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("mark_refused", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.mark_refused"); + } + + oprot->writeMessageBegin("mark_refused", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.mark_refused", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_update_compaction_metrics_data(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.update_compaction_metrics_data", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.update_compaction_metrics_data"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.update_compaction_metrics_data"); + } + + ThriftHiveMetastore_update_compaction_metrics_data_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.update_compaction_metrics_data", bytes); + } + + ThriftHiveMetastore_update_compaction_metrics_data_result result; + try { + result.success = iface_->update_compaction_metrics_data(args.data); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.update_compaction_metrics_data"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("update_compaction_metrics_data", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.update_compaction_metrics_data"); + } + + oprot->writeMessageBegin("update_compaction_metrics_data", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.update_compaction_metrics_data", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_remove_compaction_metrics_data(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.remove_compaction_metrics_data", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.remove_compaction_metrics_data"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.remove_compaction_metrics_data"); + } + + ThriftHiveMetastore_remove_compaction_metrics_data_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.remove_compaction_metrics_data", bytes); + } + + ThriftHiveMetastore_remove_compaction_metrics_data_result result; + try { + iface_->remove_compaction_metrics_data(args.request); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.remove_compaction_metrics_data"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("remove_compaction_metrics_data", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.remove_compaction_metrics_data"); + } + + oprot->writeMessageBegin("remove_compaction_metrics_data", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.remove_compaction_metrics_data", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_set_hadoop_jobid(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.set_hadoop_jobid", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.set_hadoop_jobid"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.set_hadoop_jobid"); + } + + ThriftHiveMetastore_set_hadoop_jobid_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.set_hadoop_jobid", bytes); + } + + ThriftHiveMetastore_set_hadoop_jobid_result result; + try { + iface_->set_hadoop_jobid(args.jobId, args.cq_id); + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.set_hadoop_jobid"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("set_hadoop_jobid", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.set_hadoop_jobid"); + } + + oprot->writeMessageBegin("set_hadoop_jobid", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.set_hadoop_jobid", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_latest_committed_compaction_info(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_latest_committed_compaction_info", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_latest_committed_compaction_info"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_latest_committed_compaction_info"); + } + + ThriftHiveMetastore_get_latest_committed_compaction_info_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_latest_committed_compaction_info", bytes); + } + + ThriftHiveMetastore_get_latest_committed_compaction_info_result result; + try { + iface_->get_latest_committed_compaction_info(result.success, args.rqst); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_latest_committed_compaction_info"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_latest_committed_compaction_info", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_latest_committed_compaction_info"); + } + + oprot->writeMessageBegin("get_latest_committed_compaction_info", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_latest_committed_compaction_info", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_next_notification(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_next_notification", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_next_notification"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_next_notification"); + } + + ThriftHiveMetastore_get_next_notification_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_next_notification", bytes); + } + + ThriftHiveMetastore_get_next_notification_result result; + try { + iface_->get_next_notification(result.success, args.rqst); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_next_notification"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_next_notification", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_next_notification"); + } + + oprot->writeMessageBegin("get_next_notification", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_next_notification", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_current_notificationEventId(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_current_notificationEventId", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_current_notificationEventId"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_current_notificationEventId"); + } + + ThriftHiveMetastore_get_current_notificationEventId_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_current_notificationEventId", bytes); + } + + ThriftHiveMetastore_get_current_notificationEventId_result result; + try { + iface_->get_current_notificationEventId(result.success); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_current_notificationEventId"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_current_notificationEventId", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_current_notificationEventId"); + } + + oprot->writeMessageBegin("get_current_notificationEventId", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_current_notificationEventId", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_notification_events_count(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_notification_events_count", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_notification_events_count"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_notification_events_count"); + } + + ThriftHiveMetastore_get_notification_events_count_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_notification_events_count", bytes); + } + + ThriftHiveMetastore_get_notification_events_count_result result; + try { + iface_->get_notification_events_count(result.success, args.rqst); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_notification_events_count"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_notification_events_count", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_notification_events_count"); + } + + oprot->writeMessageBegin("get_notification_events_count", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_notification_events_count", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_fire_listener_event(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.fire_listener_event", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.fire_listener_event"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.fire_listener_event"); + } + + ThriftHiveMetastore_fire_listener_event_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.fire_listener_event", bytes); + } + + ThriftHiveMetastore_fire_listener_event_result result; + try { + iface_->fire_listener_event(result.success, args.rqst); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.fire_listener_event"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("fire_listener_event", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.fire_listener_event"); + } + + oprot->writeMessageBegin("fire_listener_event", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.fire_listener_event", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_flushCache(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.flushCache", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.flushCache"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.flushCache"); + } + + ThriftHiveMetastore_flushCache_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.flushCache", bytes); + } + + ThriftHiveMetastore_flushCache_result result; + try { + iface_->flushCache(); + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.flushCache"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("flushCache", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.flushCache"); + } + + oprot->writeMessageBegin("flushCache", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.flushCache", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_add_write_notification_log(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.add_write_notification_log", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.add_write_notification_log"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.add_write_notification_log"); + } + + ThriftHiveMetastore_add_write_notification_log_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.add_write_notification_log", bytes); + } + + ThriftHiveMetastore_add_write_notification_log_result result; + try { + iface_->add_write_notification_log(result.success, args.rqst); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.add_write_notification_log"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("add_write_notification_log", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.add_write_notification_log"); + } + + oprot->writeMessageBegin("add_write_notification_log", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.add_write_notification_log", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_add_write_notification_log_in_batch(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.add_write_notification_log_in_batch", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.add_write_notification_log_in_batch"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.add_write_notification_log_in_batch"); + } + + ThriftHiveMetastore_add_write_notification_log_in_batch_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.add_write_notification_log_in_batch", bytes); + } + + ThriftHiveMetastore_add_write_notification_log_in_batch_result result; + try { + iface_->add_write_notification_log_in_batch(result.success, args.rqst); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.add_write_notification_log_in_batch"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("add_write_notification_log_in_batch", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.add_write_notification_log_in_batch"); + } + + oprot->writeMessageBegin("add_write_notification_log_in_batch", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.add_write_notification_log_in_batch", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_cm_recycle(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.cm_recycle", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.cm_recycle"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.cm_recycle"); + } + + ThriftHiveMetastore_cm_recycle_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.cm_recycle", bytes); + } + + ThriftHiveMetastore_cm_recycle_result result; + try { + iface_->cm_recycle(result.success, args.request); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.cm_recycle"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("cm_recycle", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.cm_recycle"); + } + + oprot->writeMessageBegin("cm_recycle", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.cm_recycle", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_file_metadata_by_expr(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_file_metadata_by_expr", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_file_metadata_by_expr"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_file_metadata_by_expr"); + } + + ThriftHiveMetastore_get_file_metadata_by_expr_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_file_metadata_by_expr", bytes); + } + + ThriftHiveMetastore_get_file_metadata_by_expr_result result; + try { + iface_->get_file_metadata_by_expr(result.success, args.req); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_file_metadata_by_expr"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_file_metadata_by_expr", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_file_metadata_by_expr"); + } + + oprot->writeMessageBegin("get_file_metadata_by_expr", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_file_metadata_by_expr", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_file_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_file_metadata", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_file_metadata"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_file_metadata"); + } + + ThriftHiveMetastore_get_file_metadata_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_file_metadata", bytes); + } + + ThriftHiveMetastore_get_file_metadata_result result; + try { + iface_->get_file_metadata(result.success, args.req); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_file_metadata"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_file_metadata", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_file_metadata"); + } + + oprot->writeMessageBegin("get_file_metadata", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_file_metadata", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_put_file_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.put_file_metadata", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.put_file_metadata"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.put_file_metadata"); + } + + ThriftHiveMetastore_put_file_metadata_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.put_file_metadata", bytes); + } + + ThriftHiveMetastore_put_file_metadata_result result; + try { + iface_->put_file_metadata(result.success, args.req); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.put_file_metadata"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("put_file_metadata", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.put_file_metadata"); + } + + oprot->writeMessageBegin("put_file_metadata", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.put_file_metadata", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_clear_file_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.clear_file_metadata", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.clear_file_metadata"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.clear_file_metadata"); + } + + ThriftHiveMetastore_clear_file_metadata_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.clear_file_metadata", bytes); + } + + ThriftHiveMetastore_clear_file_metadata_result result; + try { + iface_->clear_file_metadata(result.success, args.req); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.clear_file_metadata"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("clear_file_metadata", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.clear_file_metadata"); + } + + oprot->writeMessageBegin("clear_file_metadata", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.clear_file_metadata", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_cache_file_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.cache_file_metadata", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.cache_file_metadata"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.cache_file_metadata"); + } + + ThriftHiveMetastore_cache_file_metadata_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.cache_file_metadata", bytes); + } + + ThriftHiveMetastore_cache_file_metadata_result result; + try { + iface_->cache_file_metadata(result.success, args.req); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.cache_file_metadata"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("cache_file_metadata", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.cache_file_metadata"); + } + + oprot->writeMessageBegin("cache_file_metadata", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.cache_file_metadata", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_metastore_db_uuid(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_metastore_db_uuid", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_metastore_db_uuid"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_metastore_db_uuid"); + } + + ThriftHiveMetastore_get_metastore_db_uuid_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_metastore_db_uuid", bytes); + } + + ThriftHiveMetastore_get_metastore_db_uuid_result result; + try { + iface_->get_metastore_db_uuid(result.success); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_metastore_db_uuid"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_metastore_db_uuid", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_metastore_db_uuid"); + } + + oprot->writeMessageBegin("get_metastore_db_uuid", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_metastore_db_uuid", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_create_resource_plan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.create_resource_plan", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.create_resource_plan"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.create_resource_plan"); + } + + ThriftHiveMetastore_create_resource_plan_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.create_resource_plan", bytes); + } + + ThriftHiveMetastore_create_resource_plan_result result; + try { + iface_->create_resource_plan(result.success, args.request); + result.__isset.success = true; + } catch (AlreadyExistsException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.create_resource_plan"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("create_resource_plan", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.create_resource_plan"); + } + + oprot->writeMessageBegin("create_resource_plan", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.create_resource_plan", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_resource_plan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_resource_plan", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_resource_plan"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_resource_plan"); + } + + ThriftHiveMetastore_get_resource_plan_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_resource_plan", bytes); + } + + ThriftHiveMetastore_get_resource_plan_result result; + try { + iface_->get_resource_plan(result.success, args.request); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_resource_plan"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_resource_plan", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_resource_plan"); + } + + oprot->writeMessageBegin("get_resource_plan", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_resource_plan", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_active_resource_plan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_active_resource_plan", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_active_resource_plan"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_active_resource_plan"); + } + + ThriftHiveMetastore_get_active_resource_plan_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_active_resource_plan", bytes); + } + + ThriftHiveMetastore_get_active_resource_plan_result result; + try { + iface_->get_active_resource_plan(result.success, args.request); + result.__isset.success = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_active_resource_plan"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_active_resource_plan", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_active_resource_plan"); + } + + oprot->writeMessageBegin("get_active_resource_plan", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_active_resource_plan", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_all_resource_plans(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_all_resource_plans", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_all_resource_plans"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_all_resource_plans"); + } + + ThriftHiveMetastore_get_all_resource_plans_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_all_resource_plans", bytes); + } + + ThriftHiveMetastore_get_all_resource_plans_result result; + try { + iface_->get_all_resource_plans(result.success, args.request); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_all_resource_plans"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_all_resource_plans", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_all_resource_plans"); + } + + oprot->writeMessageBegin("get_all_resource_plans", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_all_resource_plans", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_alter_resource_plan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.alter_resource_plan", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.alter_resource_plan"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.alter_resource_plan"); + } + + ThriftHiveMetastore_alter_resource_plan_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.alter_resource_plan", bytes); + } + + ThriftHiveMetastore_alter_resource_plan_result result; + try { + iface_->alter_resource_plan(result.success, args.request); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidOperationException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.alter_resource_plan"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("alter_resource_plan", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.alter_resource_plan"); + } + + oprot->writeMessageBegin("alter_resource_plan", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.alter_resource_plan", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_validate_resource_plan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.validate_resource_plan", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.validate_resource_plan"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.validate_resource_plan"); + } + + ThriftHiveMetastore_validate_resource_plan_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.validate_resource_plan", bytes); + } + + ThriftHiveMetastore_validate_resource_plan_result result; + try { + iface_->validate_resource_plan(result.success, args.request); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.validate_resource_plan"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("validate_resource_plan", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.validate_resource_plan"); + } + + oprot->writeMessageBegin("validate_resource_plan", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.validate_resource_plan", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_resource_plan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_resource_plan", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_resource_plan"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_resource_plan"); + } + + ThriftHiveMetastore_drop_resource_plan_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_resource_plan", bytes); + } + + ThriftHiveMetastore_drop_resource_plan_result result; + try { + iface_->drop_resource_plan(result.success, args.request); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidOperationException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_resource_plan"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_resource_plan", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_resource_plan"); + } + + oprot->writeMessageBegin("drop_resource_plan", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_resource_plan", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_create_wm_trigger(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.create_wm_trigger", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.create_wm_trigger"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.create_wm_trigger"); + } + + ThriftHiveMetastore_create_wm_trigger_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.create_wm_trigger", bytes); + } + + ThriftHiveMetastore_create_wm_trigger_result result; + try { + iface_->create_wm_trigger(result.success, args.request); + result.__isset.success = true; + } catch (AlreadyExistsException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (InvalidObjectException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (MetaException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.create_wm_trigger"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("create_wm_trigger", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.create_wm_trigger"); + } + + oprot->writeMessageBegin("create_wm_trigger", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.create_wm_trigger", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_alter_wm_trigger(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.alter_wm_trigger", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.alter_wm_trigger"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.alter_wm_trigger"); + } + + ThriftHiveMetastore_alter_wm_trigger_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.alter_wm_trigger", bytes); + } + + ThriftHiveMetastore_alter_wm_trigger_result result; + try { + iface_->alter_wm_trigger(result.success, args.request); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.alter_wm_trigger"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("alter_wm_trigger", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.alter_wm_trigger"); + } + + oprot->writeMessageBegin("alter_wm_trigger", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.alter_wm_trigger", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_wm_trigger(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_wm_trigger", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_wm_trigger"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_wm_trigger"); + } + + ThriftHiveMetastore_drop_wm_trigger_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_wm_trigger", bytes); + } + + ThriftHiveMetastore_drop_wm_trigger_result result; + try { + iface_->drop_wm_trigger(result.success, args.request); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidOperationException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_wm_trigger"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_wm_trigger", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_wm_trigger"); + } + + oprot->writeMessageBegin("drop_wm_trigger", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_wm_trigger", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_triggers_for_resourceplan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_triggers_for_resourceplan", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_triggers_for_resourceplan"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_triggers_for_resourceplan"); + } + + ThriftHiveMetastore_get_triggers_for_resourceplan_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_triggers_for_resourceplan", bytes); + } + + ThriftHiveMetastore_get_triggers_for_resourceplan_result result; + try { + iface_->get_triggers_for_resourceplan(result.success, args.request); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_triggers_for_resourceplan"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_triggers_for_resourceplan", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_triggers_for_resourceplan"); + } + + oprot->writeMessageBegin("get_triggers_for_resourceplan", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_triggers_for_resourceplan", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_create_wm_pool(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.create_wm_pool", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.create_wm_pool"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.create_wm_pool"); + } + + ThriftHiveMetastore_create_wm_pool_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.create_wm_pool", bytes); + } + + ThriftHiveMetastore_create_wm_pool_result result; + try { + iface_->create_wm_pool(result.success, args.request); + result.__isset.success = true; + } catch (AlreadyExistsException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (InvalidObjectException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (MetaException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.create_wm_pool"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("create_wm_pool", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.create_wm_pool"); + } + + oprot->writeMessageBegin("create_wm_pool", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.create_wm_pool", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_alter_wm_pool(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.alter_wm_pool", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.alter_wm_pool"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.alter_wm_pool"); + } + + ThriftHiveMetastore_alter_wm_pool_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.alter_wm_pool", bytes); + } + + ThriftHiveMetastore_alter_wm_pool_result result; + try { + iface_->alter_wm_pool(result.success, args.request); + result.__isset.success = true; + } catch (AlreadyExistsException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (InvalidObjectException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (MetaException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.alter_wm_pool"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("alter_wm_pool", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.alter_wm_pool"); + } + + oprot->writeMessageBegin("alter_wm_pool", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.alter_wm_pool", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_wm_pool(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_wm_pool", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_wm_pool"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_wm_pool"); + } + + ThriftHiveMetastore_drop_wm_pool_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_wm_pool", bytes); + } + + ThriftHiveMetastore_drop_wm_pool_result result; + try { + iface_->drop_wm_pool(result.success, args.request); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidOperationException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_wm_pool"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_wm_pool", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_wm_pool"); + } + + oprot->writeMessageBegin("drop_wm_pool", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_wm_pool", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_create_or_update_wm_mapping(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.create_or_update_wm_mapping", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.create_or_update_wm_mapping"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.create_or_update_wm_mapping"); + } + + ThriftHiveMetastore_create_or_update_wm_mapping_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.create_or_update_wm_mapping", bytes); + } + + ThriftHiveMetastore_create_or_update_wm_mapping_result result; + try { + iface_->create_or_update_wm_mapping(result.success, args.request); + result.__isset.success = true; + } catch (AlreadyExistsException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (InvalidObjectException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (MetaException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.create_or_update_wm_mapping"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("create_or_update_wm_mapping", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.create_or_update_wm_mapping"); + } + + oprot->writeMessageBegin("create_or_update_wm_mapping", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.create_or_update_wm_mapping", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_wm_mapping(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_wm_mapping", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_wm_mapping"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_wm_mapping"); + } + + ThriftHiveMetastore_drop_wm_mapping_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_wm_mapping", bytes); + } + + ThriftHiveMetastore_drop_wm_mapping_result result; + try { + iface_->drop_wm_mapping(result.success, args.request); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidOperationException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_wm_mapping"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_wm_mapping", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_wm_mapping"); + } + + oprot->writeMessageBegin("drop_wm_mapping", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_wm_mapping", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_create_or_drop_wm_trigger_to_pool_mapping(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.create_or_drop_wm_trigger_to_pool_mapping", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.create_or_drop_wm_trigger_to_pool_mapping"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.create_or_drop_wm_trigger_to_pool_mapping"); + } + + ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.create_or_drop_wm_trigger_to_pool_mapping", bytes); + } + + ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result result; + try { + iface_->create_or_drop_wm_trigger_to_pool_mapping(result.success, args.request); + result.__isset.success = true; + } catch (AlreadyExistsException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (InvalidObjectException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (MetaException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.create_or_drop_wm_trigger_to_pool_mapping"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("create_or_drop_wm_trigger_to_pool_mapping", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.create_or_drop_wm_trigger_to_pool_mapping"); + } + + oprot->writeMessageBegin("create_or_drop_wm_trigger_to_pool_mapping", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.create_or_drop_wm_trigger_to_pool_mapping", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_create_ischema(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.create_ischema", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.create_ischema"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.create_ischema"); + } + + ThriftHiveMetastore_create_ischema_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.create_ischema", bytes); + } + + ThriftHiveMetastore_create_ischema_result result; + try { + iface_->create_ischema(args.schema); + } catch (AlreadyExistsException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.create_ischema"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("create_ischema", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.create_ischema"); + } + + oprot->writeMessageBegin("create_ischema", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.create_ischema", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_alter_ischema(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.alter_ischema", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.alter_ischema"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.alter_ischema"); + } + + ThriftHiveMetastore_alter_ischema_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.alter_ischema", bytes); + } + + ThriftHiveMetastore_alter_ischema_result result; + try { + iface_->alter_ischema(args.rqst); + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.alter_ischema"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("alter_ischema", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.alter_ischema"); + } + + oprot->writeMessageBegin("alter_ischema", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.alter_ischema", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_ischema(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_ischema", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_ischema"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_ischema"); + } + + ThriftHiveMetastore_get_ischema_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_ischema", bytes); + } + + ThriftHiveMetastore_get_ischema_result result; + try { + iface_->get_ischema(result.success, args.name); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_ischema"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_ischema", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_ischema"); + } + + oprot->writeMessageBegin("get_ischema", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_ischema", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_ischema(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_ischema", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_ischema"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_ischema"); + } + + ThriftHiveMetastore_drop_ischema_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_ischema", bytes); + } + + ThriftHiveMetastore_drop_ischema_result result; + try { + iface_->drop_ischema(args.name); + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidOperationException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_ischema"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_ischema", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_ischema"); + } + + oprot->writeMessageBegin("drop_ischema", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_ischema", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_add_schema_version(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.add_schema_version", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.add_schema_version"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.add_schema_version"); + } + + ThriftHiveMetastore_add_schema_version_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.add_schema_version", bytes); + } + + ThriftHiveMetastore_add_schema_version_result result; + try { + iface_->add_schema_version(args.schemaVersion); + } catch (AlreadyExistsException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.add_schema_version"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("add_schema_version", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.add_schema_version"); + } + + oprot->writeMessageBegin("add_schema_version", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.add_schema_version", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_schema_version(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_schema_version", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_schema_version"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_schema_version"); + } + + ThriftHiveMetastore_get_schema_version_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_schema_version", bytes); + } + + ThriftHiveMetastore_get_schema_version_result result; + try { + iface_->get_schema_version(result.success, args.schemaVersion); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_schema_version"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_schema_version", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_schema_version"); + } + + oprot->writeMessageBegin("get_schema_version", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_schema_version", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_schema_latest_version(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_schema_latest_version", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_schema_latest_version"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_schema_latest_version"); + } + + ThriftHiveMetastore_get_schema_latest_version_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_schema_latest_version", bytes); + } + + ThriftHiveMetastore_get_schema_latest_version_result result; + try { + iface_->get_schema_latest_version(result.success, args.schemaName); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_schema_latest_version"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_schema_latest_version", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_schema_latest_version"); + } + + oprot->writeMessageBegin("get_schema_latest_version", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_schema_latest_version", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_schema_all_versions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_schema_all_versions", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_schema_all_versions"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_schema_all_versions"); + } + + ThriftHiveMetastore_get_schema_all_versions_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_schema_all_versions", bytes); + } + + ThriftHiveMetastore_get_schema_all_versions_result result; + try { + iface_->get_schema_all_versions(result.success, args.schemaName); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_schema_all_versions"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_schema_all_versions", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_schema_all_versions"); + } + + oprot->writeMessageBegin("get_schema_all_versions", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_schema_all_versions", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_schema_version(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_schema_version", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_schema_version"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_schema_version"); + } + + ThriftHiveMetastore_drop_schema_version_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_schema_version", bytes); + } + + ThriftHiveMetastore_drop_schema_version_result result; + try { + iface_->drop_schema_version(args.schemaVersion); + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_schema_version"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_schema_version", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_schema_version"); + } + + oprot->writeMessageBegin("drop_schema_version", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_schema_version", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_schemas_by_cols(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_schemas_by_cols", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_schemas_by_cols"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_schemas_by_cols"); + } + + ThriftHiveMetastore_get_schemas_by_cols_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_schemas_by_cols", bytes); + } + + ThriftHiveMetastore_get_schemas_by_cols_result result; + try { + iface_->get_schemas_by_cols(result.success, args.rqst); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_schemas_by_cols"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_schemas_by_cols", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_schemas_by_cols"); + } + + oprot->writeMessageBegin("get_schemas_by_cols", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_schemas_by_cols", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_map_schema_version_to_serde(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.map_schema_version_to_serde", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.map_schema_version_to_serde"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.map_schema_version_to_serde"); + } + + ThriftHiveMetastore_map_schema_version_to_serde_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.map_schema_version_to_serde", bytes); + } + + ThriftHiveMetastore_map_schema_version_to_serde_result result; + try { + iface_->map_schema_version_to_serde(args.rqst); + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.map_schema_version_to_serde"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("map_schema_version_to_serde", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.map_schema_version_to_serde"); + } + + oprot->writeMessageBegin("map_schema_version_to_serde", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.map_schema_version_to_serde", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_set_schema_version_state(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.set_schema_version_state", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.set_schema_version_state"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.set_schema_version_state"); + } + + ThriftHiveMetastore_set_schema_version_state_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.set_schema_version_state", bytes); + } + + ThriftHiveMetastore_set_schema_version_state_result result; + try { + iface_->set_schema_version_state(args.rqst); + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidOperationException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.set_schema_version_state"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("set_schema_version_state", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.set_schema_version_state"); + } + + oprot->writeMessageBegin("set_schema_version_state", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.set_schema_version_state", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_add_serde(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.add_serde", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.add_serde"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.add_serde"); + } + + ThriftHiveMetastore_add_serde_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.add_serde", bytes); + } + + ThriftHiveMetastore_add_serde_result result; + try { + iface_->add_serde(args.serde); + } catch (AlreadyExistsException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.add_serde"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("add_serde", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.add_serde"); + } + + oprot->writeMessageBegin("add_serde", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.add_serde", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_serde(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_serde", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_serde"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_serde"); + } + + ThriftHiveMetastore_get_serde_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_serde", bytes); + } + + ThriftHiveMetastore_get_serde_result result; + try { + iface_->get_serde(result.success, args.rqst); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_serde"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_serde", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_serde"); + } + + oprot->writeMessageBegin("get_serde", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_serde", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_lock_materialization_rebuild(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_lock_materialization_rebuild", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_lock_materialization_rebuild"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_lock_materialization_rebuild"); + } + + ThriftHiveMetastore_get_lock_materialization_rebuild_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_lock_materialization_rebuild", bytes); + } + + ThriftHiveMetastore_get_lock_materialization_rebuild_result result; + try { + iface_->get_lock_materialization_rebuild(result.success, args.dbName, args.tableName, args.txnId); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_lock_materialization_rebuild"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_lock_materialization_rebuild", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_lock_materialization_rebuild"); + } + + oprot->writeMessageBegin("get_lock_materialization_rebuild", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_lock_materialization_rebuild", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_heartbeat_lock_materialization_rebuild(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.heartbeat_lock_materialization_rebuild", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.heartbeat_lock_materialization_rebuild"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.heartbeat_lock_materialization_rebuild"); + } + + ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.heartbeat_lock_materialization_rebuild", bytes); + } + + ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result result; + try { + result.success = iface_->heartbeat_lock_materialization_rebuild(args.dbName, args.tableName, args.txnId); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.heartbeat_lock_materialization_rebuild"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("heartbeat_lock_materialization_rebuild", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.heartbeat_lock_materialization_rebuild"); + } + + oprot->writeMessageBegin("heartbeat_lock_materialization_rebuild", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.heartbeat_lock_materialization_rebuild", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_add_runtime_stats(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.add_runtime_stats", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.add_runtime_stats"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.add_runtime_stats"); + } + + ThriftHiveMetastore_add_runtime_stats_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.add_runtime_stats", bytes); + } + + ThriftHiveMetastore_add_runtime_stats_result result; + try { + iface_->add_runtime_stats(args.stat); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.add_runtime_stats"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("add_runtime_stats", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.add_runtime_stats"); + } + + oprot->writeMessageBegin("add_runtime_stats", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.add_runtime_stats", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_runtime_stats(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_runtime_stats", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_runtime_stats"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_runtime_stats"); + } + + ThriftHiveMetastore_get_runtime_stats_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_runtime_stats", bytes); + } + + ThriftHiveMetastore_get_runtime_stats_result result; + try { + iface_->get_runtime_stats(result.success, args.rqst); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_runtime_stats"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_runtime_stats", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_runtime_stats"); + } + + oprot->writeMessageBegin("get_runtime_stats", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_runtime_stats", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_partitions_with_specs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_partitions_with_specs", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_partitions_with_specs"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_partitions_with_specs"); + } + + ThriftHiveMetastore_get_partitions_with_specs_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_partitions_with_specs", bytes); + } + + ThriftHiveMetastore_get_partitions_with_specs_result result; + try { + iface_->get_partitions_with_specs(result.success, args.request); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_partitions_with_specs"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_partitions_with_specs", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_partitions_with_specs"); + } + + oprot->writeMessageBegin("get_partitions_with_specs", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_partitions_with_specs", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_scheduled_query_poll(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.scheduled_query_poll", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.scheduled_query_poll"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.scheduled_query_poll"); + } + + ThriftHiveMetastore_scheduled_query_poll_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.scheduled_query_poll", bytes); + } + + ThriftHiveMetastore_scheduled_query_poll_result result; + try { + iface_->scheduled_query_poll(result.success, args.request); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.scheduled_query_poll"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("scheduled_query_poll", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.scheduled_query_poll"); + } + + oprot->writeMessageBegin("scheduled_query_poll", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.scheduled_query_poll", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_scheduled_query_maintenance(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.scheduled_query_maintenance", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.scheduled_query_maintenance"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.scheduled_query_maintenance"); + } + + ThriftHiveMetastore_scheduled_query_maintenance_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.scheduled_query_maintenance", bytes); + } + + ThriftHiveMetastore_scheduled_query_maintenance_result result; + try { + iface_->scheduled_query_maintenance(args.request); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (AlreadyExistsException &o3) { + result.o3 = std::move(o3); + result.__isset.o3 = true; + } catch (InvalidInputException &o4) { + result.o4 = std::move(o4); + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.scheduled_query_maintenance"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("scheduled_query_maintenance", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.scheduled_query_maintenance"); + } + + oprot->writeMessageBegin("scheduled_query_maintenance", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.scheduled_query_maintenance", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_scheduled_query_progress(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.scheduled_query_progress", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.scheduled_query_progress"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.scheduled_query_progress"); + } + + ThriftHiveMetastore_scheduled_query_progress_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.scheduled_query_progress", bytes); + } + + ThriftHiveMetastore_scheduled_query_progress_result result; + try { + iface_->scheduled_query_progress(args.info); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (InvalidOperationException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.scheduled_query_progress"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("scheduled_query_progress", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.scheduled_query_progress"); + } + + oprot->writeMessageBegin("scheduled_query_progress", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.scheduled_query_progress", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_scheduled_query(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_scheduled_query", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_scheduled_query"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_scheduled_query"); + } + + ThriftHiveMetastore_get_scheduled_query_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_scheduled_query", bytes); + } + + ThriftHiveMetastore_get_scheduled_query_result result; + try { + iface_->get_scheduled_query(result.success, args.scheduleKey); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_scheduled_query"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_scheduled_query", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_scheduled_query"); + } + + oprot->writeMessageBegin("get_scheduled_query", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_scheduled_query", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_add_replication_metrics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.add_replication_metrics", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.add_replication_metrics"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.add_replication_metrics"); + } + + ThriftHiveMetastore_add_replication_metrics_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.add_replication_metrics", bytes); + } + + ThriftHiveMetastore_add_replication_metrics_result result; + try { + iface_->add_replication_metrics(args.replicationMetricList); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.add_replication_metrics"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("add_replication_metrics", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.add_replication_metrics"); + } + + oprot->writeMessageBegin("add_replication_metrics", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.add_replication_metrics", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_replication_metrics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_replication_metrics", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_replication_metrics"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_replication_metrics"); + } + + ThriftHiveMetastore_get_replication_metrics_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_replication_metrics", bytes); + } + + ThriftHiveMetastore_get_replication_metrics_result result; + try { + iface_->get_replication_metrics(result.success, args.rqst); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_replication_metrics"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_replication_metrics", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_replication_metrics"); + } + + oprot->writeMessageBegin("get_replication_metrics", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_replication_metrics", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_open_txns_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_open_txns_req", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_open_txns_req"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_open_txns_req"); + } + + ThriftHiveMetastore_get_open_txns_req_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_open_txns_req", bytes); + } + + ThriftHiveMetastore_get_open_txns_req_result result; + try { + iface_->get_open_txns_req(result.success, args.getOpenTxnsRequest); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_open_txns_req"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_open_txns_req", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_open_txns_req"); + } + + oprot->writeMessageBegin("get_open_txns_req", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_open_txns_req", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_create_stored_procedure(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.create_stored_procedure", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.create_stored_procedure"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.create_stored_procedure"); + } + + ThriftHiveMetastore_create_stored_procedure_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.create_stored_procedure", bytes); + } + + ThriftHiveMetastore_create_stored_procedure_result result; + try { + iface_->create_stored_procedure(args.proc); + } catch (NoSuchObjectException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (MetaException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.create_stored_procedure"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("create_stored_procedure", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.create_stored_procedure"); + } + + oprot->writeMessageBegin("create_stored_procedure", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.create_stored_procedure", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_stored_procedure(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_stored_procedure", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_stored_procedure"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_stored_procedure"); + } + + ThriftHiveMetastore_get_stored_procedure_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_stored_procedure", bytes); + } + + ThriftHiveMetastore_get_stored_procedure_result result; + try { + iface_->get_stored_procedure(result.success, args.request); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_stored_procedure"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_stored_procedure", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_stored_procedure"); + } + + oprot->writeMessageBegin("get_stored_procedure", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_stored_procedure", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_stored_procedure(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_stored_procedure", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_stored_procedure"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_stored_procedure"); + } + + ThriftHiveMetastore_drop_stored_procedure_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_stored_procedure", bytes); + } + + ThriftHiveMetastore_drop_stored_procedure_result result; + try { + iface_->drop_stored_procedure(args.request); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_stored_procedure"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_stored_procedure", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_stored_procedure"); + } + + oprot->writeMessageBegin("drop_stored_procedure", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_stored_procedure", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_all_stored_procedures(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_all_stored_procedures", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_all_stored_procedures"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_all_stored_procedures"); + } + + ThriftHiveMetastore_get_all_stored_procedures_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_all_stored_procedures", bytes); + } + + ThriftHiveMetastore_get_all_stored_procedures_result result; + try { + iface_->get_all_stored_procedures(result.success, args.request); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_all_stored_procedures"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_all_stored_procedures", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_all_stored_procedures"); + } + + oprot->writeMessageBegin("get_all_stored_procedures", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_all_stored_procedures", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_find_package(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.find_package", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.find_package"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.find_package"); + } + + ThriftHiveMetastore_find_package_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.find_package", bytes); + } + + ThriftHiveMetastore_find_package_result result; + try { + iface_->find_package(result.success, args.request); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = std::move(o2); + result.__isset.o2 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.find_package"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("find_package", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.find_package"); + } + + oprot->writeMessageBegin("find_package", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.find_package", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_add_package(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.add_package", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.add_package"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.add_package"); + } + + ThriftHiveMetastore_add_package_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.add_package", bytes); + } + + ThriftHiveMetastore_add_package_result result; + try { + iface_->add_package(args.request); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.add_package"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("add_package", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.add_package"); + } + + oprot->writeMessageBegin("add_package", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.add_package", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_all_packages(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_all_packages", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_all_packages"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_all_packages"); + } + + ThriftHiveMetastore_get_all_packages_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_all_packages", bytes); + } + + ThriftHiveMetastore_get_all_packages_result result; + try { + iface_->get_all_packages(result.success, args.request); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_all_packages"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_all_packages", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_all_packages"); + } + + oprot->writeMessageBegin("get_all_packages", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_all_packages", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_package(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_package", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_package"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_package"); + } + + ThriftHiveMetastore_drop_package_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_package", bytes); + } + + ThriftHiveMetastore_drop_package_result result; + try { + iface_->drop_package(args.request); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_package"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_package", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_package"); + } + + oprot->writeMessageBegin("drop_package", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_package", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_all_write_event_info(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_all_write_event_info", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_all_write_event_info"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_all_write_event_info"); + } + + ThriftHiveMetastore_get_all_write_event_info_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_all_write_event_info", bytes); + } + + ThriftHiveMetastore_get_all_write_event_info_result result; + try { + iface_->get_all_write_event_info(result.success, args.request); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_all_write_event_info"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_all_write_event_info", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_all_write_event_info"); + } + + oprot->writeMessageBegin("get_all_write_event_info", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_all_write_event_info", bytes); + } +} + +::std::shared_ptr< ::apache::thrift::TProcessor > ThriftHiveMetastoreProcessorFactory::getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) { + ::apache::thrift::ReleaseHandler< ThriftHiveMetastoreIfFactory > cleanup(handlerFactory_); + ::std::shared_ptr< ThriftHiveMetastoreIf > handler(handlerFactory_->getHandler(connInfo), cleanup); + ::std::shared_ptr< ::apache::thrift::TProcessor > processor(new ThriftHiveMetastoreProcessor(handler)); + return processor; +} + +void ThriftHiveMetastoreConcurrentClient::abort_Compactions(AbortCompactResponse& _return, const AbortCompactionRequest& rqst) +{ + int32_t seqid = send_abort_Compactions(rqst); + recv_abort_Compactions(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_abort_Compactions(const AbortCompactionRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("abort_Compactions", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_abort_Compactions_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_abort_Compactions(AbortCompactResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("abort_Compactions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_abort_Compactions_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "abort_Compactions failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::getMetaConf(std::string& _return, const std::string& key) +{ + int32_t seqid = send_getMetaConf(key); + recv_getMetaConf(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_getMetaConf(const std::string& key) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("getMetaConf", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_getMetaConf_pargs args; + args.key = &key; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_getMetaConf(std::string& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getMetaConf") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_getMetaConf_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getMetaConf failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::setMetaConf(const std::string& key, const std::string& value) +{ + int32_t seqid = send_setMetaConf(key, value); + recv_setMetaConf(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_setMetaConf(const std::string& key, const std::string& value) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("setMetaConf", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_setMetaConf_pargs args; + args.key = &key; + args.value = &value; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_setMetaConf(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("setMetaConf") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_setMetaConf_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::create_catalog(const CreateCatalogRequest& catalog) +{ + int32_t seqid = send_create_catalog(catalog); + recv_create_catalog(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_create_catalog(const CreateCatalogRequest& catalog) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("create_catalog", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_catalog_pargs args; + args.catalog = &catalog; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_create_catalog(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_catalog") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_create_catalog_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::alter_catalog(const AlterCatalogRequest& rqst) +{ + int32_t seqid = send_alter_catalog(rqst); + recv_alter_catalog(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_catalog(const AlterCatalogRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("alter_catalog", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_catalog_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_alter_catalog(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_catalog") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_alter_catalog_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_catalog(GetCatalogResponse& _return, const GetCatalogRequest& catName) +{ + int32_t seqid = send_get_catalog(catName); + recv_get_catalog(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_catalog(const GetCatalogRequest& catName) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_catalog", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_catalog_pargs args; + args.catName = &catName; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_catalog(GetCatalogResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_catalog") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_catalog_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_catalog failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_catalogs(GetCatalogsResponse& _return) +{ + int32_t seqid = send_get_catalogs(); + recv_get_catalogs(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_catalogs() +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_catalogs", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_catalogs_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_catalogs(GetCatalogsResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_catalogs") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_catalogs_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_catalogs failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::drop_catalog(const DropCatalogRequest& catName) +{ + int32_t seqid = send_drop_catalog(catName); + recv_drop_catalog(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_catalog(const DropCatalogRequest& catName) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_catalog", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_catalog_pargs args; + args.catName = &catName; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_drop_catalog(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_catalog") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_drop_catalog_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::create_database(const Database& database) +{ + int32_t seqid = send_create_database(database); + recv_create_database(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_create_database(const Database& database) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("create_database", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_database_pargs args; + args.database = &database; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_create_database(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_database") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_create_database_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::create_database_req(const CreateDatabaseRequest& createDatabaseRequest) +{ + int32_t seqid = send_create_database_req(createDatabaseRequest); + recv_create_database_req(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_create_database_req(const CreateDatabaseRequest& createDatabaseRequest) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("create_database_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_database_req_pargs args; + args.createDatabaseRequest = &createDatabaseRequest; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_create_database_req(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_database_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_create_database_req_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_database(Database& _return, const std::string& name) +{ + int32_t seqid = send_get_database(name); + recv_get_database(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_database(const std::string& name) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_database", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_database_pargs args; + args.name = &name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_database(Database& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_database") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_database_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_database failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_database_req(Database& _return, const GetDatabaseRequest& request) +{ + int32_t seqid = send_get_database_req(request); + recv_get_database_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_database_req(const GetDatabaseRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_database_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_database_req_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_database_req(Database& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_database_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_database_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_database_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::drop_database(const std::string& name, const bool deleteData, const bool cascade) +{ + int32_t seqid = send_drop_database(name, deleteData, cascade); + recv_drop_database(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_database(const std::string& name, const bool deleteData, const bool cascade) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_database", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_database_pargs args; + args.name = &name; + args.deleteData = &deleteData; + args.cascade = &cascade; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_drop_database(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_database") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_drop_database_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::drop_database_req(const DropDatabaseRequest& req) +{ + int32_t seqid = send_drop_database_req(req); + recv_drop_database_req(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_database_req(const DropDatabaseRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_database_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_database_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_drop_database_req(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_database_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_drop_database_req_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_databases(std::vector & _return, const std::string& pattern) +{ + int32_t seqid = send_get_databases(pattern); + recv_get_databases(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_databases(const std::string& pattern) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_databases", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_databases_pargs args; + args.pattern = &pattern; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_databases(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_databases") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_databases_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_databases failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_all_databases(std::vector & _return) +{ + int32_t seqid = send_get_all_databases(); + recv_get_all_databases(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_databases() +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_all_databases", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_all_databases_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_all_databases(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_all_databases") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_all_databases_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_databases failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::alter_database(const std::string& dbname, const Database& db) +{ + int32_t seqid = send_alter_database(dbname, db); + recv_alter_database(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_database(const std::string& dbname, const Database& db) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("alter_database", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_database_pargs args; + args.dbname = &dbname; + args.db = &db; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_alter_database(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_database") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_alter_database_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::alter_database_req(const AlterDatabaseRequest& alterDbReq) +{ + int32_t seqid = send_alter_database_req(alterDbReq); + recv_alter_database_req(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_database_req(const AlterDatabaseRequest& alterDbReq) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("alter_database_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_database_req_pargs args; + args.alterDbReq = &alterDbReq; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_alter_database_req(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_database_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_alter_database_req_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::create_dataconnector_req(const CreateDataConnectorRequest& connectorReq) +{ + int32_t seqid = send_create_dataconnector_req(connectorReq); + recv_create_dataconnector_req(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_create_dataconnector_req(const CreateDataConnectorRequest& connectorReq) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("create_dataconnector_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_dataconnector_req_pargs args; + args.connectorReq = &connectorReq; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_create_dataconnector_req(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_dataconnector_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_create_dataconnector_req_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_dataconnector_req(DataConnector& _return, const GetDataConnectorRequest& request) +{ + int32_t seqid = send_get_dataconnector_req(request); + recv_get_dataconnector_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_dataconnector_req(const GetDataConnectorRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_dataconnector_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_dataconnector_req_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_dataconnector_req(DataConnector& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_dataconnector_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_dataconnector_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_dataconnector_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::drop_dataconnector_req(const DropDataConnectorRequest& dropDcReq) +{ + int32_t seqid = send_drop_dataconnector_req(dropDcReq); + recv_drop_dataconnector_req(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_dataconnector_req(const DropDataConnectorRequest& dropDcReq) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_dataconnector_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_dataconnector_req_pargs args; + args.dropDcReq = &dropDcReq; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_drop_dataconnector_req(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_dataconnector_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_drop_dataconnector_req_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_dataconnectors(std::vector & _return) +{ + int32_t seqid = send_get_dataconnectors(); + recv_get_dataconnectors(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_dataconnectors() +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_dataconnectors", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_dataconnectors_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_dataconnectors(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_dataconnectors") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_dataconnectors_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_dataconnectors failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::alter_dataconnector_req(const AlterDataConnectorRequest& alterReq) +{ + int32_t seqid = send_alter_dataconnector_req(alterReq); + recv_alter_dataconnector_req(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_dataconnector_req(const AlterDataConnectorRequest& alterReq) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("alter_dataconnector_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_dataconnector_req_pargs args; + args.alterReq = &alterReq; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_alter_dataconnector_req(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_dataconnector_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_alter_dataconnector_req_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_type(Type& _return, const std::string& name) +{ + int32_t seqid = send_get_type(name); + recv_get_type(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_type(const std::string& name) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_type", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_type_pargs args; + args.name = &name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_type(Type& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_type") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_type_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_type failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::create_type(const Type& type) +{ + int32_t seqid = send_create_type(type); + return recv_create_type(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_create_type(const Type& type) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("create_type", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_type_pargs args; + args.type = &type; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_create_type(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_type") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_create_type_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "create_type failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::drop_type(const std::string& type) +{ + int32_t seqid = send_drop_type(type); + return recv_drop_type(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_type(const std::string& type) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_type", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_type_pargs args; + args.type = &type; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_drop_type(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_type") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_drop_type_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_type failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_type_all(std::map & _return, const std::string& name) +{ + int32_t seqid = send_get_type_all(name); + recv_get_type_all(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_type_all(const std::string& name) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_type_all", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_type_all_pargs args; + args.name = &name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_type_all(std::map & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_type_all") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_type_all_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_type_all failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_fields(std::vector & _return, const std::string& db_name, const std::string& table_name) +{ + int32_t seqid = send_get_fields(db_name, table_name); + recv_get_fields(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_fields(const std::string& db_name, const std::string& table_name) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_fields", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_fields_pargs args; + args.db_name = &db_name; + args.table_name = &table_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_fields(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_fields") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_fields_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_fields failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_fields_with_environment_context(std::vector & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) +{ + int32_t seqid = send_get_fields_with_environment_context(db_name, table_name, environment_context); + recv_get_fields_with_environment_context(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_fields_with_environment_context(const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_fields_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_fields_with_environment_context_pargs args; + args.db_name = &db_name; + args.table_name = &table_name; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_fields_with_environment_context(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_fields_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_fields_with_environment_context_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_fields_with_environment_context failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_fields_req(GetFieldsResponse& _return, const GetFieldsRequest& req) +{ + int32_t seqid = send_get_fields_req(req); + recv_get_fields_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_fields_req(const GetFieldsRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_fields_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_fields_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_fields_req(GetFieldsResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_fields_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_fields_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_fields_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_schema(std::vector & _return, const std::string& db_name, const std::string& table_name) +{ + int32_t seqid = send_get_schema(db_name, table_name); + recv_get_schema(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_schema(const std::string& db_name, const std::string& table_name) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_schema", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_schema_pargs args; + args.db_name = &db_name; + args.table_name = &table_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_schema(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_schema") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_schema_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_schema failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_schema_with_environment_context(std::vector & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) +{ + int32_t seqid = send_get_schema_with_environment_context(db_name, table_name, environment_context); + recv_get_schema_with_environment_context(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_schema_with_environment_context(const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_schema_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_schema_with_environment_context_pargs args; + args.db_name = &db_name; + args.table_name = &table_name; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_schema_with_environment_context(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_schema_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_schema_with_environment_context_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_schema_with_environment_context failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_schema_req(GetSchemaResponse& _return, const GetSchemaRequest& req) +{ + int32_t seqid = send_get_schema_req(req); + recv_get_schema_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_schema_req(const GetSchemaRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_schema_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_schema_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_schema_req(GetSchemaResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_schema_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_schema_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_schema_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::create_table(const Table& tbl) +{ + int32_t seqid = send_create_table(tbl); + recv_create_table(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_create_table(const Table& tbl) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("create_table", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_table_pargs args; + args.tbl = &tbl; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_create_table(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_table") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_create_table_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context) +{ + int32_t seqid = send_create_table_with_environment_context(tbl, environment_context); + recv_create_table_with_environment_context(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("create_table_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_table_with_environment_context_pargs args; + args.tbl = &tbl; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_create_table_with_environment_context(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_table_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_create_table_with_environment_context_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys, const std::vector & uniqueConstraints, const std::vector & notNullConstraints, const std::vector & defaultConstraints, const std::vector & checkConstraints) +{ + int32_t seqid = send_create_table_with_constraints(tbl, primaryKeys, foreignKeys, uniqueConstraints, notNullConstraints, defaultConstraints, checkConstraints); + recv_create_table_with_constraints(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys, const std::vector & uniqueConstraints, const std::vector & notNullConstraints, const std::vector & defaultConstraints, const std::vector & checkConstraints) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("create_table_with_constraints", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_table_with_constraints_pargs args; + args.tbl = &tbl; + args.primaryKeys = &primaryKeys; + args.foreignKeys = &foreignKeys; + args.uniqueConstraints = &uniqueConstraints; + args.notNullConstraints = ¬NullConstraints; + args.defaultConstraints = &defaultConstraints; + args.checkConstraints = &checkConstraints; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_create_table_with_constraints(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_table_with_constraints") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_create_table_with_constraints_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::create_table_req(const CreateTableRequest& request) +{ + int32_t seqid = send_create_table_req(request); + recv_create_table_req(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_create_table_req(const CreateTableRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("create_table_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_table_req_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_create_table_req(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_table_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_create_table_req_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::drop_constraint(const DropConstraintRequest& req) +{ + int32_t seqid = send_drop_constraint(req); + recv_drop_constraint(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_constraint(const DropConstraintRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_constraint", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_constraint_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_drop_constraint(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_constraint") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_drop_constraint_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::add_primary_key(const AddPrimaryKeyRequest& req) +{ + int32_t seqid = send_add_primary_key(req); + recv_add_primary_key(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_add_primary_key(const AddPrimaryKeyRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("add_primary_key", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_primary_key_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_add_primary_key(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_primary_key") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_add_primary_key_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::add_foreign_key(const AddForeignKeyRequest& req) +{ + int32_t seqid = send_add_foreign_key(req); + recv_add_foreign_key(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_add_foreign_key(const AddForeignKeyRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("add_foreign_key", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_foreign_key_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_add_foreign_key(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_foreign_key") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_add_foreign_key_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::add_unique_constraint(const AddUniqueConstraintRequest& req) +{ + int32_t seqid = send_add_unique_constraint(req); + recv_add_unique_constraint(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_add_unique_constraint(const AddUniqueConstraintRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("add_unique_constraint", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_unique_constraint_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_add_unique_constraint(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_unique_constraint") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_add_unique_constraint_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::add_not_null_constraint(const AddNotNullConstraintRequest& req) +{ + int32_t seqid = send_add_not_null_constraint(req); + recv_add_not_null_constraint(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_add_not_null_constraint(const AddNotNullConstraintRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("add_not_null_constraint", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_not_null_constraint_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_add_not_null_constraint(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_not_null_constraint") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_add_not_null_constraint_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::add_default_constraint(const AddDefaultConstraintRequest& req) +{ + int32_t seqid = send_add_default_constraint(req); + recv_add_default_constraint(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_add_default_constraint(const AddDefaultConstraintRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("add_default_constraint", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_default_constraint_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_add_default_constraint(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_default_constraint") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_add_default_constraint_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::add_check_constraint(const AddCheckConstraintRequest& req) +{ + int32_t seqid = send_add_check_constraint(req); + recv_add_check_constraint(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_add_check_constraint(const AddCheckConstraintRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("add_check_constraint", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_check_constraint_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_add_check_constraint(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_check_constraint") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_add_check_constraint_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::translate_table_dryrun(Table& _return, const CreateTableRequest& request) +{ + int32_t seqid = send_translate_table_dryrun(request); + recv_translate_table_dryrun(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_translate_table_dryrun(const CreateTableRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("translate_table_dryrun", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_translate_table_dryrun_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_translate_table_dryrun(Table& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("translate_table_dryrun") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_translate_table_dryrun_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "translate_table_dryrun failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::drop_table(const std::string& dbname, const std::string& name, const bool deleteData) +{ + int32_t seqid = send_drop_table(dbname, name, deleteData); + recv_drop_table(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_table(const std::string& dbname, const std::string& name, const bool deleteData) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_table", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_table_pargs args; + args.dbname = &dbname; + args.name = &name; + args.deleteData = &deleteData; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_drop_table(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_table") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_drop_table_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context) +{ + int32_t seqid = send_drop_table_with_environment_context(dbname, name, deleteData, environment_context); + recv_drop_table_with_environment_context(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_table_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_table_with_environment_context_pargs args; + args.dbname = &dbname; + args.name = &name; + args.deleteData = &deleteData; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_drop_table_with_environment_context(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_table_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_drop_table_with_environment_context_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::drop_table_req(const DropTableRequest& dropTableReq) +{ + int32_t seqid = send_drop_table_req(dropTableReq); + recv_drop_table_req(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_table_req(const DropTableRequest& dropTableReq) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_table_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_table_req_pargs args; + args.dropTableReq = &dropTableReq; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_drop_table_req(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_table_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_drop_table_req_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames) +{ + int32_t seqid = send_truncate_table(dbName, tableName, partNames); + recv_truncate_table(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("truncate_table", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_truncate_table_pargs args; + args.dbName = &dbName; + args.tableName = &tableName; + args.partNames = &partNames; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_truncate_table(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("truncate_table") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_truncate_table_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::truncate_table_req(TruncateTableResponse& _return, const TruncateTableRequest& req) +{ + int32_t seqid = send_truncate_table_req(req); + recv_truncate_table_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_truncate_table_req(const TruncateTableRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("truncate_table_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_truncate_table_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_truncate_table_req(TruncateTableResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("truncate_table_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_truncate_table_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "truncate_table_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_tables(std::vector & _return, const std::string& db_name, const std::string& pattern) +{ + int32_t seqid = send_get_tables(db_name, pattern); + recv_get_tables(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_tables(const std::string& db_name, const std::string& pattern) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_tables", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_tables_pargs args; + args.db_name = &db_name; + args.pattern = &pattern; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_tables(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_tables") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_tables_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_tables failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_tables_by_type(std::vector & _return, const std::string& db_name, const std::string& pattern, const std::string& tableType) +{ + int32_t seqid = send_get_tables_by_type(db_name, pattern, tableType); + recv_get_tables_by_type(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_tables_by_type(const std::string& db_name, const std::string& pattern, const std::string& tableType) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_tables_by_type", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_tables_by_type_pargs args; + args.db_name = &db_name; + args.pattern = &pattern; + args.tableType = &tableType; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_tables_by_type(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_tables_by_type") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_tables_by_type_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_tables_by_type failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_all_materialized_view_objects_for_rewriting(std::vector
& _return) +{ + int32_t seqid = send_get_all_materialized_view_objects_for_rewriting(); + recv_get_all_materialized_view_objects_for_rewriting(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_materialized_view_objects_for_rewriting() +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_all_materialized_view_objects_for_rewriting", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_all_materialized_view_objects_for_rewriting(std::vector
& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_all_materialized_view_objects_for_rewriting") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_materialized_view_objects_for_rewriting failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_materialized_views_for_rewriting(std::vector & _return, const std::string& db_name) +{ + int32_t seqid = send_get_materialized_views_for_rewriting(db_name); + recv_get_materialized_views_for_rewriting(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_materialized_views_for_rewriting(const std::string& db_name) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_materialized_views_for_rewriting", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_materialized_views_for_rewriting_pargs args; + args.db_name = &db_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_materialized_views_for_rewriting(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_materialized_views_for_rewriting") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_materialized_views_for_rewriting_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_materialized_views_for_rewriting failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_table_meta(std::vector & _return, const std::string& db_patterns, const std::string& tbl_patterns, const std::vector & tbl_types) +{ + int32_t seqid = send_get_table_meta(db_patterns, tbl_patterns, tbl_types); + recv_get_table_meta(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_table_meta(const std::string& db_patterns, const std::string& tbl_patterns, const std::vector & tbl_types) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_table_meta", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_table_meta_pargs args; + args.db_patterns = &db_patterns; + args.tbl_patterns = &tbl_patterns; + args.tbl_types = &tbl_types; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_table_meta(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_table_meta") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_table_meta_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_table_meta failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_all_tables(std::vector & _return, const std::string& db_name) +{ + int32_t seqid = send_get_all_tables(db_name); + recv_get_all_tables(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_tables(const std::string& db_name) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_all_tables", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_all_tables_pargs args; + args.db_name = &db_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_all_tables(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_all_tables") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_all_tables_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_tables failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_tables_ext(std::vector & _return, const GetTablesExtRequest& req) +{ + int32_t seqid = send_get_tables_ext(req); + recv_get_tables_ext(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_tables_ext(const GetTablesExtRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_tables_ext", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_tables_ext_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_tables_ext(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_tables_ext") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_tables_ext_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_tables_ext failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_table_req(GetTableResult& _return, const GetTableRequest& req) +{ + int32_t seqid = send_get_table_req(req); + recv_get_table_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_table_req(const GetTableRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_table_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_table_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_table_req(GetTableResult& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_table_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_table_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_table_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_table_objects_by_name_req(GetTablesResult& _return, const GetTablesRequest& req) +{ + int32_t seqid = send_get_table_objects_by_name_req(req); + recv_get_table_objects_by_name_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_table_objects_by_name_req(const GetTablesRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_table_objects_by_name_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_table_objects_by_name_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_table_objects_by_name_req(GetTablesResult& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_table_objects_by_name_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_table_objects_by_name_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_table_objects_by_name_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_materialization_invalidation_info(Materialization& _return, const CreationMetadata& creation_metadata, const std::string& validTxnList) +{ + int32_t seqid = send_get_materialization_invalidation_info(creation_metadata, validTxnList); + recv_get_materialization_invalidation_info(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_materialization_invalidation_info(const CreationMetadata& creation_metadata, const std::string& validTxnList) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_materialization_invalidation_info", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_materialization_invalidation_info_pargs args; + args.creation_metadata = &creation_metadata; + args.validTxnList = &validTxnList; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_materialization_invalidation_info(Materialization& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_materialization_invalidation_info") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_materialization_invalidation_info_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_materialization_invalidation_info failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::update_creation_metadata(const std::string& catName, const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata) +{ + int32_t seqid = send_update_creation_metadata(catName, dbname, tbl_name, creation_metadata); + recv_update_creation_metadata(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_update_creation_metadata(const std::string& catName, const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("update_creation_metadata", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_update_creation_metadata_pargs args; + args.catName = &catName; + args.dbname = &dbname; + args.tbl_name = &tbl_name; + args.creation_metadata = &creation_metadata; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_update_creation_metadata(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("update_creation_metadata") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_update_creation_metadata_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_table_names_by_filter(std::vector & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables) +{ + int32_t seqid = send_get_table_names_by_filter(dbname, filter, max_tables); + recv_get_table_names_by_filter(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_table_names_by_filter(const std::string& dbname, const std::string& filter, const int16_t max_tables) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_table_names_by_filter", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_table_names_by_filter_pargs args; + args.dbname = &dbname; + args.filter = &filter; + args.max_tables = &max_tables; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_table_names_by_filter(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_table_names_by_filter") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_table_names_by_filter_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_table_names_by_filter failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl) +{ + int32_t seqid = send_alter_table(dbname, tbl_name, new_tbl); + recv_alter_table(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("alter_table", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_table_pargs args; + args.dbname = &dbname; + args.tbl_name = &tbl_name; + args.new_tbl = &new_tbl; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_alter_table(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_table") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_alter_table_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context) +{ + int32_t seqid = send_alter_table_with_environment_context(dbname, tbl_name, new_tbl, environment_context); + recv_alter_table_with_environment_context(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("alter_table_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_table_with_environment_context_pargs args; + args.dbname = &dbname; + args.tbl_name = &tbl_name; + args.new_tbl = &new_tbl; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_alter_table_with_environment_context(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_table_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_alter_table_with_environment_context_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade) +{ + int32_t seqid = send_alter_table_with_cascade(dbname, tbl_name, new_tbl, cascade); + recv_alter_table_with_cascade(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("alter_table_with_cascade", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_table_with_cascade_pargs args; + args.dbname = &dbname; + args.tbl_name = &tbl_name; + args.new_tbl = &new_tbl; + args.cascade = &cascade; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_alter_table_with_cascade(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_table_with_cascade") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_alter_table_with_cascade_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::alter_table_req(AlterTableResponse& _return, const AlterTableRequest& req) +{ + int32_t seqid = send_alter_table_req(req); + recv_alter_table_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_table_req(const AlterTableRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("alter_table_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_table_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_alter_table_req(AlterTableResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_table_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_alter_table_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "alter_table_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::add_partition(Partition& _return, const Partition& new_part) +{ + int32_t seqid = send_add_partition(new_part); + recv_add_partition(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_add_partition(const Partition& new_part) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("add_partition", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_partition_pargs args; + args.new_part = &new_part; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_add_partition(Partition& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_partition") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_add_partition_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "add_partition failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::add_partition_with_environment_context(Partition& _return, const Partition& new_part, const EnvironmentContext& environment_context) +{ + int32_t seqid = send_add_partition_with_environment_context(new_part, environment_context); + recv_add_partition_with_environment_context(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_add_partition_with_environment_context(const Partition& new_part, const EnvironmentContext& environment_context) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("add_partition_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_partition_with_environment_context_pargs args; + args.new_part = &new_part; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_add_partition_with_environment_context(Partition& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_partition_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_add_partition_with_environment_context_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "add_partition_with_environment_context failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +int32_t ThriftHiveMetastoreConcurrentClient::add_partitions(const std::vector & new_parts) +{ + int32_t seqid = send_add_partitions(new_parts); + return recv_add_partitions(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_add_partitions(const std::vector & new_parts) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("add_partitions", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_partitions_pargs args; + args.new_parts = &new_parts; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +int32_t ThriftHiveMetastoreConcurrentClient::recv_add_partitions(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_partitions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + int32_t _return; + ThriftHiveMetastore_add_partitions_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "add_partitions failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +int32_t ThriftHiveMetastoreConcurrentClient::add_partitions_pspec(const std::vector & new_parts) +{ + int32_t seqid = send_add_partitions_pspec(new_parts); + return recv_add_partitions_pspec(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_add_partitions_pspec(const std::vector & new_parts) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("add_partitions_pspec", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_partitions_pspec_pargs args; + args.new_parts = &new_parts; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +int32_t ThriftHiveMetastoreConcurrentClient::recv_add_partitions_pspec(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_partitions_pspec") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + int32_t _return; + ThriftHiveMetastore_add_partitions_pspec_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "add_partitions_pspec failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::append_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals) +{ + int32_t seqid = send_append_partition(db_name, tbl_name, part_vals); + recv_append_partition(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_append_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("append_partition", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_append_partition_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_append_partition(Partition& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("append_partition") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_append_partition_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "append_partition failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::add_partitions_req(AddPartitionsResult& _return, const AddPartitionsRequest& request) +{ + int32_t seqid = send_add_partitions_req(request); + recv_add_partitions_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_add_partitions_req(const AddPartitionsRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("add_partitions_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_partitions_req_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_add_partitions_req(AddPartitionsResult& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_partitions_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_add_partitions_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "add_partitions_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::append_partition_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const EnvironmentContext& environment_context) +{ + int32_t seqid = send_append_partition_with_environment_context(db_name, tbl_name, part_vals, environment_context); + recv_append_partition_with_environment_context(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_append_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const EnvironmentContext& environment_context) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("append_partition_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_append_partition_with_environment_context_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_append_partition_with_environment_context(Partition& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("append_partition_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_append_partition_with_environment_context_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "append_partition_with_environment_context failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::append_partition_req(Partition& _return, const AppendPartitionsRequest& appendPartitionsReq) +{ + int32_t seqid = send_append_partition_req(appendPartitionsReq); + recv_append_partition_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_append_partition_req(const AppendPartitionsRequest& appendPartitionsReq) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("append_partition_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_append_partition_req_pargs args; + args.appendPartitionsReq = &appendPartitionsReq; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_append_partition_req(Partition& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("append_partition_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_append_partition_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "append_partition_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::append_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name) +{ + int32_t seqid = send_append_partition_by_name(db_name, tbl_name, part_name); + recv_append_partition_by_name(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_append_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("append_partition_by_name", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_append_partition_by_name_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_name = &part_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_append_partition_by_name(Partition& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("append_partition_by_name") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_append_partition_by_name_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "append_partition_by_name failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::append_partition_by_name_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context) +{ + int32_t seqid = send_append_partition_by_name_with_environment_context(db_name, tbl_name, part_name, environment_context); + recv_append_partition_by_name_with_environment_context(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_append_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("append_partition_by_name_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_append_partition_by_name_with_environment_context_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_name = &part_name; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_append_partition_by_name_with_environment_context(Partition& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("append_partition_by_name_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_append_partition_by_name_with_environment_context_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "append_partition_by_name_with_environment_context failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData) +{ + int32_t seqid = send_drop_partition(db_name, tbl_name, part_vals, deleteData); + return recv_drop_partition(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_partition", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_partition_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.deleteData = &deleteData; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_drop_partition(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_partition") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_drop_partition_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_partition failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::drop_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData, const EnvironmentContext& environment_context) +{ + int32_t seqid = send_drop_partition_with_environment_context(db_name, tbl_name, part_vals, deleteData, environment_context); + return recv_drop_partition_with_environment_context(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData, const EnvironmentContext& environment_context) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_partition_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_partition_with_environment_context_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.deleteData = &deleteData; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_drop_partition_with_environment_context(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_partition_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_drop_partition_with_environment_context_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_partition_with_environment_context failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::drop_partition_req(const DropPartitionRequest& dropPartitionReq) +{ + int32_t seqid = send_drop_partition_req(dropPartitionReq); + return recv_drop_partition_req(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_partition_req(const DropPartitionRequest& dropPartitionReq) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_partition_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_partition_req_pargs args; + args.dropPartitionReq = &dropPartitionReq; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_drop_partition_req(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_partition_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_drop_partition_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_partition_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData) +{ + int32_t seqid = send_drop_partition_by_name(db_name, tbl_name, part_name, deleteData); + return recv_drop_partition_by_name(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_partition_by_name", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_partition_by_name_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_name = &part_name; + args.deleteData = &deleteData; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_drop_partition_by_name(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_partition_by_name") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_drop_partition_by_name_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_partition_by_name failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::drop_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData, const EnvironmentContext& environment_context) +{ + int32_t seqid = send_drop_partition_by_name_with_environment_context(db_name, tbl_name, part_name, deleteData, environment_context); + return recv_drop_partition_by_name_with_environment_context(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData, const EnvironmentContext& environment_context) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_partition_by_name_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_partition_by_name_with_environment_context_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_name = &part_name; + args.deleteData = &deleteData; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_drop_partition_by_name_with_environment_context(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_partition_by_name_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_drop_partition_by_name_with_environment_context_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_partition_by_name_with_environment_context failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::drop_partitions_req(DropPartitionsResult& _return, const DropPartitionsRequest& req) +{ + int32_t seqid = send_drop_partitions_req(req); + recv_drop_partitions_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_partitions_req(const DropPartitionsRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_partitions_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_partitions_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_drop_partitions_req(DropPartitionsResult& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_partitions_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_drop_partitions_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_partitions_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals) +{ + int32_t seqid = send_get_partition(db_name, tbl_name, part_vals); + recv_get_partition(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partition", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partition_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partition(Partition& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partition") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partition_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partition failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partition_req(GetPartitionResponse& _return, const GetPartitionRequest& req) +{ + int32_t seqid = send_get_partition_req(req); + recv_get_partition_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partition_req(const GetPartitionRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partition_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partition_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partition_req(GetPartitionResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partition_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partition_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partition_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::exchange_partition(Partition& _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) +{ + int32_t seqid = send_exchange_partition(partitionSpecs, source_db, source_table_name, dest_db, dest_table_name); + recv_exchange_partition(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_exchange_partition(const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("exchange_partition", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_exchange_partition_pargs args; + args.partitionSpecs = &partitionSpecs; + args.source_db = &source_db; + args.source_table_name = &source_table_name; + args.dest_db = &dest_db; + args.dest_table_name = &dest_table_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_exchange_partition(Partition& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("exchange_partition") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_exchange_partition_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "exchange_partition failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::exchange_partitions(std::vector & _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) +{ + int32_t seqid = send_exchange_partitions(partitionSpecs, source_db, source_table_name, dest_db, dest_table_name); + recv_exchange_partitions(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_exchange_partitions(const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("exchange_partitions", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_exchange_partitions_pargs args; + args.partitionSpecs = &partitionSpecs; + args.source_db = &source_db; + args.source_table_name = &source_table_name; + args.dest_db = &dest_db; + args.dest_table_name = &dest_table_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_exchange_partitions(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("exchange_partitions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_exchange_partitions_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "exchange_partitions failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partition_with_auth(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const std::string& user_name, const std::vector & group_names) +{ + int32_t seqid = send_get_partition_with_auth(db_name, tbl_name, part_vals, user_name, group_names); + recv_get_partition_with_auth(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partition_with_auth(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const std::string& user_name, const std::vector & group_names) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partition_with_auth", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partition_with_auth_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.user_name = &user_name; + args.group_names = &group_names; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partition_with_auth(Partition& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partition_with_auth") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partition_with_auth_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partition_with_auth failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name) +{ + int32_t seqid = send_get_partition_by_name(db_name, tbl_name, part_name); + recv_get_partition_by_name(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partition_by_name", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partition_by_name_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_name = &part_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partition_by_name(Partition& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partition_by_name") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partition_by_name_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partition_by_name failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partitions(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts) +{ + int32_t seqid = send_get_partitions(db_name, tbl_name, max_parts); + recv_get_partitions(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partitions(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partitions", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.max_parts = &max_parts; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partitions(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partitions_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partitions_req(PartitionsResponse& _return, const PartitionsRequest& req) +{ + int32_t seqid = send_get_partitions_req(req); + recv_get_partitions_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partitions_req(const PartitionsRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partitions_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partitions_req(PartitionsResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partitions_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partitions_with_auth(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts, const std::string& user_name, const std::vector & group_names) +{ + int32_t seqid = send_get_partitions_with_auth(db_name, tbl_name, max_parts, user_name, group_names); + recv_get_partitions_with_auth(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partitions_with_auth(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts, const std::string& user_name, const std::vector & group_names) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partitions_with_auth", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_with_auth_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.max_parts = &max_parts; + args.user_name = &user_name; + args.group_names = &group_names; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partitions_with_auth(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_with_auth") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partitions_with_auth_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_with_auth failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partitions_pspec(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int32_t max_parts) +{ + int32_t seqid = send_get_partitions_pspec(db_name, tbl_name, max_parts); + recv_get_partitions_pspec(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partitions_pspec(const std::string& db_name, const std::string& tbl_name, const int32_t max_parts) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partitions_pspec", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_pspec_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.max_parts = &max_parts; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partitions_pspec(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_pspec") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partitions_pspec_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_pspec failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partition_names(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts) +{ + int32_t seqid = send_get_partition_names(db_name, tbl_name, max_parts); + recv_get_partition_names(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partition_names(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partition_names", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partition_names_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.max_parts = &max_parts; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partition_names(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partition_names") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partition_names_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partition_names failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::fetch_partition_names_req(std::vector & _return, const PartitionsRequest& partitionReq) +{ + int32_t seqid = send_fetch_partition_names_req(partitionReq); + recv_fetch_partition_names_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_fetch_partition_names_req(const PartitionsRequest& partitionReq) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("fetch_partition_names_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_fetch_partition_names_req_pargs args; + args.partitionReq = &partitionReq; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_fetch_partition_names_req(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("fetch_partition_names_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_fetch_partition_names_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "fetch_partition_names_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partition_values(PartitionValuesResponse& _return, const PartitionValuesRequest& request) +{ + int32_t seqid = send_get_partition_values(request); + recv_get_partition_values(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partition_values(const PartitionValuesRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partition_values", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partition_values_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partition_values(PartitionValuesResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partition_values") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partition_values_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partition_values failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partitions_ps(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts) +{ + int32_t seqid = send_get_partitions_ps(db_name, tbl_name, part_vals, max_parts); + recv_get_partitions_ps(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partitions_ps(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partitions_ps", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_ps_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.max_parts = &max_parts; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partitions_ps(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_ps") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partitions_ps_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_ps failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partitions_ps_with_auth(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts, const std::string& user_name, const std::vector & group_names) +{ + int32_t seqid = send_get_partitions_ps_with_auth(db_name, tbl_name, part_vals, max_parts, user_name, group_names); + recv_get_partitions_ps_with_auth(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partitions_ps_with_auth(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts, const std::string& user_name, const std::vector & group_names) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partitions_ps_with_auth", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_ps_with_auth_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.max_parts = &max_parts; + args.user_name = &user_name; + args.group_names = &group_names; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partitions_ps_with_auth(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_ps_with_auth") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partitions_ps_with_auth_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_ps_with_auth failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partitions_ps_with_auth_req(GetPartitionsPsWithAuthResponse& _return, const GetPartitionsPsWithAuthRequest& req) +{ + int32_t seqid = send_get_partitions_ps_with_auth_req(req); + recv_get_partitions_ps_with_auth_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partitions_ps_with_auth_req(const GetPartitionsPsWithAuthRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partitions_ps_with_auth_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_ps_with_auth_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partitions_ps_with_auth_req(GetPartitionsPsWithAuthResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_ps_with_auth_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partitions_ps_with_auth_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_ps_with_auth_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partition_names_ps(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts) +{ + int32_t seqid = send_get_partition_names_ps(db_name, tbl_name, part_vals, max_parts); + recv_get_partition_names_ps(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partition_names_ps(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partition_names_ps", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partition_names_ps_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.max_parts = &max_parts; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partition_names_ps(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partition_names_ps") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partition_names_ps_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partition_names_ps failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partition_names_ps_req(GetPartitionNamesPsResponse& _return, const GetPartitionNamesPsRequest& req) +{ + int32_t seqid = send_get_partition_names_ps_req(req); + recv_get_partition_names_ps_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partition_names_ps_req(const GetPartitionNamesPsRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partition_names_ps_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partition_names_ps_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partition_names_ps_req(GetPartitionNamesPsResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partition_names_ps_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partition_names_ps_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partition_names_ps_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partition_names_req(std::vector & _return, const PartitionsByExprRequest& req) +{ + int32_t seqid = send_get_partition_names_req(req); + recv_get_partition_names_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partition_names_req(const PartitionsByExprRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partition_names_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partition_names_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partition_names_req(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partition_names_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partition_names_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partition_names_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partitions_by_filter(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int16_t max_parts) +{ + int32_t seqid = send_get_partitions_by_filter(db_name, tbl_name, filter, max_parts); + recv_get_partitions_by_filter(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int16_t max_parts) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partitions_by_filter", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_by_filter_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.filter = &filter; + args.max_parts = &max_parts; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partitions_by_filter(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_by_filter") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partitions_by_filter_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_by_filter failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partitions_by_filter_req(std::vector & _return, const GetPartitionsByFilterRequest& req) +{ + int32_t seqid = send_get_partitions_by_filter_req(req); + recv_get_partitions_by_filter_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partitions_by_filter_req(const GetPartitionsByFilterRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partitions_by_filter_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_by_filter_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partitions_by_filter_req(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_by_filter_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partitions_by_filter_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_by_filter_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_part_specs_by_filter(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int32_t max_parts) +{ + int32_t seqid = send_get_part_specs_by_filter(db_name, tbl_name, filter, max_parts); + recv_get_part_specs_by_filter(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_part_specs_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int32_t max_parts) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_part_specs_by_filter", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_part_specs_by_filter_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.filter = &filter; + args.max_parts = &max_parts; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_part_specs_by_filter(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_part_specs_by_filter") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_part_specs_by_filter_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_part_specs_by_filter failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partitions_by_expr(PartitionsByExprResult& _return, const PartitionsByExprRequest& req) +{ + int32_t seqid = send_get_partitions_by_expr(req); + recv_get_partitions_by_expr(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partitions_by_expr(const PartitionsByExprRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partitions_by_expr", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_by_expr_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partitions_by_expr(PartitionsByExprResult& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_by_expr") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partitions_by_expr_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_by_expr failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partitions_spec_by_expr(PartitionsSpecByExprResult& _return, const PartitionsByExprRequest& req) +{ + int32_t seqid = send_get_partitions_spec_by_expr(req); + recv_get_partitions_spec_by_expr(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partitions_spec_by_expr(const PartitionsByExprRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partitions_spec_by_expr", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_spec_by_expr_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partitions_spec_by_expr(PartitionsSpecByExprResult& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_spec_by_expr") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partitions_spec_by_expr_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_spec_by_expr failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +int32_t ThriftHiveMetastoreConcurrentClient::get_num_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter) +{ + int32_t seqid = send_get_num_partitions_by_filter(db_name, tbl_name, filter); + return recv_get_num_partitions_by_filter(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_num_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_num_partitions_by_filter", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_num_partitions_by_filter_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.filter = &filter; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +int32_t ThriftHiveMetastoreConcurrentClient::recv_get_num_partitions_by_filter(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_num_partitions_by_filter") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + int32_t _return; + ThriftHiveMetastore_get_num_partitions_by_filter_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_num_partitions_by_filter failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partitions_by_names(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & names) +{ + int32_t seqid = send_get_partitions_by_names(db_name, tbl_name, names); + recv_get_partitions_by_names(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partitions_by_names(const std::string& db_name, const std::string& tbl_name, const std::vector & names) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partitions_by_names", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_by_names_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.names = &names; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partitions_by_names(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_by_names") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partitions_by_names_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_by_names failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partitions_by_names_req(GetPartitionsByNamesResult& _return, const GetPartitionsByNamesRequest& req) +{ + int32_t seqid = send_get_partitions_by_names_req(req); + recv_get_partitions_by_names_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partitions_by_names_req(const GetPartitionsByNamesRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partitions_by_names_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_by_names_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partitions_by_names_req(GetPartitionsByNamesResult& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_by_names_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partitions_by_names_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_by_names_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_properties(PropertyGetResponse& _return, const PropertyGetRequest& req) +{ + int32_t seqid = send_get_properties(req); + recv_get_properties(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_properties(const PropertyGetRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_properties", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_properties_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_properties(PropertyGetResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_properties") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_properties_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.e1) { + sentry.commit(); + throw result.e1; + } + if (result.__isset.e2) { + sentry.commit(); + throw result.e2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_properties failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::set_properties(const PropertySetRequest& req) +{ + int32_t seqid = send_set_properties(req); + return recv_set_properties(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_set_properties(const PropertySetRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("set_properties", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_set_properties_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_set_properties(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("set_properties") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_set_properties_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.e1) { + sentry.commit(); + throw result.e1; + } + if (result.__isset.e2) { + sentry.commit(); + throw result.e2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "set_properties failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::alter_partition(const std::string& db_name, const std::string& tbl_name, const Partition& new_part) +{ + int32_t seqid = send_alter_partition(db_name, tbl_name, new_part); + recv_alter_partition(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_partition(const std::string& db_name, const std::string& tbl_name, const Partition& new_part) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("alter_partition", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_partition_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.new_part = &new_part; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_alter_partition(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_partition") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_alter_partition_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts) +{ + int32_t seqid = send_alter_partitions(db_name, tbl_name, new_parts); + recv_alter_partitions(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("alter_partitions", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_partitions_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.new_parts = &new_parts; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_alter_partitions(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_partitions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_alter_partitions_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::alter_partitions_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts, const EnvironmentContext& environment_context) +{ + int32_t seqid = send_alter_partitions_with_environment_context(db_name, tbl_name, new_parts, environment_context); + recv_alter_partitions_with_environment_context(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_partitions_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts, const EnvironmentContext& environment_context) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("alter_partitions_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_partitions_with_environment_context_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.new_parts = &new_parts; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_alter_partitions_with_environment_context(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_partitions_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_alter_partitions_with_environment_context_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::alter_partitions_req(AlterPartitionsResponse& _return, const AlterPartitionsRequest& req) +{ + int32_t seqid = send_alter_partitions_req(req); + recv_alter_partitions_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_partitions_req(const AlterPartitionsRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("alter_partitions_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_partitions_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_alter_partitions_req(AlterPartitionsResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_partitions_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_alter_partitions_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "alter_partitions_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context) +{ + int32_t seqid = send_alter_partition_with_environment_context(db_name, tbl_name, new_part, environment_context); + recv_alter_partition_with_environment_context(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("alter_partition_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_partition_with_environment_context_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.new_part = &new_part; + args.environment_context = &environment_context; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_alter_partition_with_environment_context(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_partition_with_environment_context") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_alter_partition_with_environment_context_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const Partition& new_part) +{ + int32_t seqid = send_rename_partition(db_name, tbl_name, part_vals, new_part); + recv_rename_partition(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const Partition& new_part) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("rename_partition", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_rename_partition_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.new_part = &new_part; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_rename_partition(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("rename_partition") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_rename_partition_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::rename_partition_req(RenamePartitionResponse& _return, const RenamePartitionRequest& req) +{ + int32_t seqid = send_rename_partition_req(req); + recv_rename_partition_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_rename_partition_req(const RenamePartitionRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("rename_partition_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_rename_partition_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_rename_partition_req(RenamePartitionResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("rename_partition_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_rename_partition_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "rename_partition_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::partition_name_has_valid_characters(const std::vector & part_vals, const bool throw_exception) +{ + int32_t seqid = send_partition_name_has_valid_characters(part_vals, throw_exception); + return recv_partition_name_has_valid_characters(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_partition_name_has_valid_characters(const std::vector & part_vals, const bool throw_exception) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("partition_name_has_valid_characters", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_partition_name_has_valid_characters_pargs args; + args.part_vals = &part_vals; + args.throw_exception = &throw_exception; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_partition_name_has_valid_characters(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("partition_name_has_valid_characters") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_partition_name_has_valid_characters_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "partition_name_has_valid_characters failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_config_value(std::string& _return, const std::string& name, const std::string& defaultValue) +{ + int32_t seqid = send_get_config_value(name, defaultValue); + recv_get_config_value(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_config_value(const std::string& name, const std::string& defaultValue) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_config_value", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_config_value_pargs args; + args.name = &name; + args.defaultValue = &defaultValue; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_config_value(std::string& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_config_value") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_config_value_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_config_value failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::partition_name_to_vals(std::vector & _return, const std::string& part_name) +{ + int32_t seqid = send_partition_name_to_vals(part_name); + recv_partition_name_to_vals(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_partition_name_to_vals(const std::string& part_name) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("partition_name_to_vals", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_partition_name_to_vals_pargs args; + args.part_name = &part_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_partition_name_to_vals(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("partition_name_to_vals") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_partition_name_to_vals_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "partition_name_to_vals failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::partition_name_to_spec(std::map & _return, const std::string& part_name) +{ + int32_t seqid = send_partition_name_to_spec(part_name); + recv_partition_name_to_spec(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_partition_name_to_spec(const std::string& part_name) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("partition_name_to_spec", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_partition_name_to_spec_pargs args; + args.part_name = &part_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_partition_name_to_spec(std::map & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("partition_name_to_spec") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_partition_name_to_spec_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "partition_name_to_spec failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::markPartitionForEvent(const std::string& db_name, const std::string& tbl_name, const std::map & part_vals, const PartitionEventType::type eventType) +{ + int32_t seqid = send_markPartitionForEvent(db_name, tbl_name, part_vals, eventType); + recv_markPartitionForEvent(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_markPartitionForEvent(const std::string& db_name, const std::string& tbl_name, const std::map & part_vals, const PartitionEventType::type eventType) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("markPartitionForEvent", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_markPartitionForEvent_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.eventType = &eventType; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_markPartitionForEvent(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("markPartitionForEvent") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_markPartitionForEvent_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + if (result.__isset.o5) { + sentry.commit(); + throw result.o5; + } + if (result.__isset.o6) { + sentry.commit(); + throw result.o6; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::isPartitionMarkedForEvent(const std::string& db_name, const std::string& tbl_name, const std::map & part_vals, const PartitionEventType::type eventType) +{ + int32_t seqid = send_isPartitionMarkedForEvent(db_name, tbl_name, part_vals, eventType); + return recv_isPartitionMarkedForEvent(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_isPartitionMarkedForEvent(const std::string& db_name, const std::string& tbl_name, const std::map & part_vals, const PartitionEventType::type eventType) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("isPartitionMarkedForEvent", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_isPartitionMarkedForEvent_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.eventType = &eventType; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_isPartitionMarkedForEvent(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("isPartitionMarkedForEvent") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_isPartitionMarkedForEvent_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + if (result.__isset.o5) { + sentry.commit(); + throw result.o5; + } + if (result.__isset.o6) { + sentry.commit(); + throw result.o6; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "isPartitionMarkedForEvent failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_primary_keys(PrimaryKeysResponse& _return, const PrimaryKeysRequest& request) +{ + int32_t seqid = send_get_primary_keys(request); + recv_get_primary_keys(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_primary_keys(const PrimaryKeysRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_primary_keys", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_primary_keys_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_primary_keys(PrimaryKeysResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_primary_keys") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_primary_keys_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_primary_keys failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_foreign_keys(ForeignKeysResponse& _return, const ForeignKeysRequest& request) +{ + int32_t seqid = send_get_foreign_keys(request); + recv_get_foreign_keys(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_foreign_keys(const ForeignKeysRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_foreign_keys", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_foreign_keys_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_foreign_keys(ForeignKeysResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_foreign_keys") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_foreign_keys_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_foreign_keys failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_unique_constraints(UniqueConstraintsResponse& _return, const UniqueConstraintsRequest& request) +{ + int32_t seqid = send_get_unique_constraints(request); + recv_get_unique_constraints(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_unique_constraints(const UniqueConstraintsRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_unique_constraints", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_unique_constraints_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_unique_constraints(UniqueConstraintsResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_unique_constraints") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_unique_constraints_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_unique_constraints failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_not_null_constraints(NotNullConstraintsResponse& _return, const NotNullConstraintsRequest& request) +{ + int32_t seqid = send_get_not_null_constraints(request); + recv_get_not_null_constraints(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_not_null_constraints(const NotNullConstraintsRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_not_null_constraints", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_not_null_constraints_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_not_null_constraints(NotNullConstraintsResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_not_null_constraints") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_not_null_constraints_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_not_null_constraints failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_default_constraints(DefaultConstraintsResponse& _return, const DefaultConstraintsRequest& request) +{ + int32_t seqid = send_get_default_constraints(request); + recv_get_default_constraints(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_default_constraints(const DefaultConstraintsRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_default_constraints", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_default_constraints_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_default_constraints(DefaultConstraintsResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_default_constraints") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_default_constraints_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_default_constraints failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_check_constraints(CheckConstraintsResponse& _return, const CheckConstraintsRequest& request) +{ + int32_t seqid = send_get_check_constraints(request); + recv_get_check_constraints(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_check_constraints(const CheckConstraintsRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_check_constraints", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_check_constraints_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_check_constraints(CheckConstraintsResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_check_constraints") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_check_constraints_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_check_constraints failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_all_table_constraints(AllTableConstraintsResponse& _return, const AllTableConstraintsRequest& request) +{ + int32_t seqid = send_get_all_table_constraints(request); + recv_get_all_table_constraints(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_table_constraints(const AllTableConstraintsRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_all_table_constraints", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_all_table_constraints_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_all_table_constraints(AllTableConstraintsResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_all_table_constraints") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_all_table_constraints_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_table_constraints failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::update_table_column_statistics(const ColumnStatistics& stats_obj) +{ + int32_t seqid = send_update_table_column_statistics(stats_obj); + return recv_update_table_column_statistics(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_update_table_column_statistics(const ColumnStatistics& stats_obj) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("update_table_column_statistics", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_update_table_column_statistics_pargs args; + args.stats_obj = &stats_obj; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_update_table_column_statistics(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("update_table_column_statistics") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_update_table_column_statistics_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "update_table_column_statistics failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::update_partition_column_statistics(const ColumnStatistics& stats_obj) +{ + int32_t seqid = send_update_partition_column_statistics(stats_obj); + return recv_update_partition_column_statistics(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_update_partition_column_statistics(const ColumnStatistics& stats_obj) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("update_partition_column_statistics", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_update_partition_column_statistics_pargs args; + args.stats_obj = &stats_obj; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_update_partition_column_statistics(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("update_partition_column_statistics") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_update_partition_column_statistics_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "update_partition_column_statistics failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::update_table_column_statistics_req(SetPartitionsStatsResponse& _return, const SetPartitionsStatsRequest& req) +{ + int32_t seqid = send_update_table_column_statistics_req(req); + recv_update_table_column_statistics_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_update_table_column_statistics_req(const SetPartitionsStatsRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("update_table_column_statistics_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_update_table_column_statistics_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_update_table_column_statistics_req(SetPartitionsStatsResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("update_table_column_statistics_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_update_table_column_statistics_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "update_table_column_statistics_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::update_partition_column_statistics_req(SetPartitionsStatsResponse& _return, const SetPartitionsStatsRequest& req) +{ + int32_t seqid = send_update_partition_column_statistics_req(req); + recv_update_partition_column_statistics_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_update_partition_column_statistics_req(const SetPartitionsStatsRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("update_partition_column_statistics_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_update_partition_column_statistics_req_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_update_partition_column_statistics_req(SetPartitionsStatsResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("update_partition_column_statistics_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_update_partition_column_statistics_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "update_partition_column_statistics_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::update_transaction_statistics(const UpdateTransactionalStatsRequest& req) +{ + int32_t seqid = send_update_transaction_statistics(req); + recv_update_transaction_statistics(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_update_transaction_statistics(const UpdateTransactionalStatsRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("update_transaction_statistics", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_update_transaction_statistics_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_update_transaction_statistics(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("update_transaction_statistics") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_update_transaction_statistics_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_table_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& col_name) +{ + int32_t seqid = send_get_table_column_statistics(db_name, tbl_name, col_name); + recv_get_table_column_statistics(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_table_column_statistics", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_table_column_statistics_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.col_name = &col_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_table_column_statistics(ColumnStatistics& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_table_column_statistics") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_table_column_statistics_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_table_column_statistics failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partition_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name) +{ + int32_t seqid = send_get_partition_column_statistics(db_name, tbl_name, part_name, col_name); + recv_get_partition_column_statistics(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partition_column_statistics", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partition_column_statistics_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_name = &part_name; + args.col_name = &col_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partition_column_statistics(ColumnStatistics& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partition_column_statistics") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partition_column_statistics_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partition_column_statistics failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_table_statistics_req(TableStatsResult& _return, const TableStatsRequest& request) +{ + int32_t seqid = send_get_table_statistics_req(request); + recv_get_table_statistics_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_table_statistics_req(const TableStatsRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_table_statistics_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_table_statistics_req_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_table_statistics_req(TableStatsResult& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_table_statistics_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_table_statistics_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_table_statistics_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partitions_statistics_req(PartitionsStatsResult& _return, const PartitionsStatsRequest& request) +{ + int32_t seqid = send_get_partitions_statistics_req(request); + recv_get_partitions_statistics_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partitions_statistics_req(const PartitionsStatsRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partitions_statistics_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_statistics_req_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partitions_statistics_req(PartitionsStatsResult& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_statistics_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partitions_statistics_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_statistics_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_aggr_stats_for(AggrStats& _return, const PartitionsStatsRequest& request) +{ + int32_t seqid = send_get_aggr_stats_for(request); + recv_get_aggr_stats_for(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_aggr_stats_for(const PartitionsStatsRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_aggr_stats_for", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_aggr_stats_for_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_aggr_stats_for(AggrStats& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_aggr_stats_for") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_aggr_stats_for_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_aggr_stats_for failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::set_aggr_stats_for(const SetPartitionsStatsRequest& request) +{ + int32_t seqid = send_set_aggr_stats_for(request); + return recv_set_aggr_stats_for(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_set_aggr_stats_for(const SetPartitionsStatsRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("set_aggr_stats_for", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_set_aggr_stats_for_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_set_aggr_stats_for(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("set_aggr_stats_for") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_set_aggr_stats_for_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "set_aggr_stats_for failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::delete_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name, const std::string& engine) +{ + int32_t seqid = send_delete_partition_column_statistics(db_name, tbl_name, part_name, col_name, engine); + return recv_delete_partition_column_statistics(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_delete_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name, const std::string& engine) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("delete_partition_column_statistics", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_delete_partition_column_statistics_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_name = &part_name; + args.col_name = &col_name; + args.engine = &engine; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_delete_partition_column_statistics(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("delete_partition_column_statistics") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_delete_partition_column_statistics_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "delete_partition_column_statistics failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::delete_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name, const std::string& engine) +{ + int32_t seqid = send_delete_table_column_statistics(db_name, tbl_name, col_name, engine); + return recv_delete_table_column_statistics(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_delete_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name, const std::string& engine) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("delete_table_column_statistics", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_delete_table_column_statistics_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.col_name = &col_name; + args.engine = &engine; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_delete_table_column_statistics(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("delete_table_column_statistics") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_delete_table_column_statistics_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "delete_table_column_statistics failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::create_function(const Function& func) +{ + int32_t seqid = send_create_function(func); + recv_create_function(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_create_function(const Function& func) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("create_function", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_function_pargs args; + args.func = &func; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_create_function(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_function") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_create_function_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::drop_function(const std::string& dbName, const std::string& funcName) +{ + int32_t seqid = send_drop_function(dbName, funcName); + recv_drop_function(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_function(const std::string& dbName, const std::string& funcName) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_function", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_function_pargs args; + args.dbName = &dbName; + args.funcName = &funcName; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_drop_function(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_function") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_drop_function_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::alter_function(const std::string& dbName, const std::string& funcName, const Function& newFunc) +{ + int32_t seqid = send_alter_function(dbName, funcName, newFunc); + recv_alter_function(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_function(const std::string& dbName, const std::string& funcName, const Function& newFunc) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("alter_function", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_function_pargs args; + args.dbName = &dbName; + args.funcName = &funcName; + args.newFunc = &newFunc; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_alter_function(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_function") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_alter_function_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_functions(std::vector & _return, const std::string& dbName, const std::string& pattern) +{ + int32_t seqid = send_get_functions(dbName, pattern); + recv_get_functions(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_functions(const std::string& dbName, const std::string& pattern) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_functions", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_functions_pargs args; + args.dbName = &dbName; + args.pattern = &pattern; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_functions(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_functions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_functions_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_functions failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_function(Function& _return, const std::string& dbName, const std::string& funcName) +{ + int32_t seqid = send_get_function(dbName, funcName); + recv_get_function(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_function(const std::string& dbName, const std::string& funcName) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_function", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_function_pargs args; + args.dbName = &dbName; + args.funcName = &funcName; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_function(Function& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_function") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_function_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_function failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_all_functions(GetAllFunctionsResponse& _return) +{ + int32_t seqid = send_get_all_functions(); + recv_get_all_functions(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_functions() +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_all_functions", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_all_functions_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_all_functions(GetAllFunctionsResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_all_functions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_all_functions_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_functions failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::create_role(const Role& role) +{ + int32_t seqid = send_create_role(role); + return recv_create_role(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_create_role(const Role& role) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("create_role", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_role_pargs args; + args.role = &role; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_create_role(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_role") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_create_role_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "create_role failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::drop_role(const std::string& role_name) +{ + int32_t seqid = send_drop_role(role_name); + return recv_drop_role(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_role(const std::string& role_name) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_role", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_role_pargs args; + args.role_name = &role_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_drop_role(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_role") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_drop_role_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_role failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_role_names(std::vector & _return) +{ + int32_t seqid = send_get_role_names(); + recv_get_role_names(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_role_names() +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_role_names", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_role_names_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_role_names(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_role_names") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_role_names_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_role_names failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::grant_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type, const std::string& grantor, const PrincipalType::type grantorType, const bool grant_option) +{ + int32_t seqid = send_grant_role(role_name, principal_name, principal_type, grantor, grantorType, grant_option); + return recv_grant_role(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_grant_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type, const std::string& grantor, const PrincipalType::type grantorType, const bool grant_option) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("grant_role", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_grant_role_pargs args; + args.role_name = &role_name; + args.principal_name = &principal_name; + args.principal_type = &principal_type; + args.grantor = &grantor; + args.grantorType = &grantorType; + args.grant_option = &grant_option; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_grant_role(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("grant_role") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_grant_role_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "grant_role failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::revoke_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type) +{ + int32_t seqid = send_revoke_role(role_name, principal_name, principal_type); + return recv_revoke_role(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_revoke_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("revoke_role", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_revoke_role_pargs args; + args.role_name = &role_name; + args.principal_name = &principal_name; + args.principal_type = &principal_type; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_revoke_role(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("revoke_role") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_revoke_role_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "revoke_role failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::list_roles(std::vector & _return, const std::string& principal_name, const PrincipalType::type principal_type) +{ + int32_t seqid = send_list_roles(principal_name, principal_type); + recv_list_roles(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_list_roles(const std::string& principal_name, const PrincipalType::type principal_type) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("list_roles", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_list_roles_pargs args; + args.principal_name = &principal_name; + args.principal_type = &principal_type; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_list_roles(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("list_roles") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_list_roles_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "list_roles failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::grant_revoke_role(GrantRevokeRoleResponse& _return, const GrantRevokeRoleRequest& request) +{ + int32_t seqid = send_grant_revoke_role(request); + recv_grant_revoke_role(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_grant_revoke_role(const GrantRevokeRoleRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("grant_revoke_role", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_grant_revoke_role_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_grant_revoke_role(GrantRevokeRoleResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("grant_revoke_role") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_grant_revoke_role_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "grant_revoke_role failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_principals_in_role(GetPrincipalsInRoleResponse& _return, const GetPrincipalsInRoleRequest& request) +{ + int32_t seqid = send_get_principals_in_role(request); + recv_get_principals_in_role(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_principals_in_role(const GetPrincipalsInRoleRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_principals_in_role", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_principals_in_role_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_principals_in_role(GetPrincipalsInRoleResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_principals_in_role") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_principals_in_role_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_principals_in_role failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& _return, const GetRoleGrantsForPrincipalRequest& request) +{ + int32_t seqid = send_get_role_grants_for_principal(request); + recv_get_role_grants_for_principal(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_role_grants_for_principal(const GetRoleGrantsForPrincipalRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_role_grants_for_principal", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_role_grants_for_principal_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_role_grants_for_principal") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_role_grants_for_principal_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_role_grants_for_principal failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_privilege_set(PrincipalPrivilegeSet& _return, const HiveObjectRef& hiveObject, const std::string& user_name, const std::vector & group_names) +{ + int32_t seqid = send_get_privilege_set(hiveObject, user_name, group_names); + recv_get_privilege_set(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_privilege_set(const HiveObjectRef& hiveObject, const std::string& user_name, const std::vector & group_names) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_privilege_set", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_privilege_set_pargs args; + args.hiveObject = &hiveObject; + args.user_name = &user_name; + args.group_names = &group_names; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_privilege_set(PrincipalPrivilegeSet& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_privilege_set") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_privilege_set_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_privilege_set failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::list_privileges(std::vector & _return, const std::string& principal_name, const PrincipalType::type principal_type, const HiveObjectRef& hiveObject) +{ + int32_t seqid = send_list_privileges(principal_name, principal_type, hiveObject); + recv_list_privileges(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_list_privileges(const std::string& principal_name, const PrincipalType::type principal_type, const HiveObjectRef& hiveObject) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("list_privileges", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_list_privileges_pargs args; + args.principal_name = &principal_name; + args.principal_type = &principal_type; + args.hiveObject = &hiveObject; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_list_privileges(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("list_privileges") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_list_privileges_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "list_privileges failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::grant_privileges(const PrivilegeBag& privileges) +{ + int32_t seqid = send_grant_privileges(privileges); + return recv_grant_privileges(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_grant_privileges(const PrivilegeBag& privileges) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("grant_privileges", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_grant_privileges_pargs args; + args.privileges = &privileges; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_grant_privileges(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("grant_privileges") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_grant_privileges_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "grant_privileges failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::revoke_privileges(const PrivilegeBag& privileges) +{ + int32_t seqid = send_revoke_privileges(privileges); + return recv_revoke_privileges(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_revoke_privileges(const PrivilegeBag& privileges) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("revoke_privileges", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_revoke_privileges_pargs args; + args.privileges = &privileges; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_revoke_privileges(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("revoke_privileges") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_revoke_privileges_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "revoke_privileges failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::grant_revoke_privileges(GrantRevokePrivilegeResponse& _return, const GrantRevokePrivilegeRequest& request) +{ + int32_t seqid = send_grant_revoke_privileges(request); + recv_grant_revoke_privileges(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_grant_revoke_privileges(const GrantRevokePrivilegeRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("grant_revoke_privileges", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_grant_revoke_privileges_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_grant_revoke_privileges(GrantRevokePrivilegeResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("grant_revoke_privileges") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_grant_revoke_privileges_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "grant_revoke_privileges failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::refresh_privileges(GrantRevokePrivilegeResponse& _return, const HiveObjectRef& objToRefresh, const std::string& authorizer, const GrantRevokePrivilegeRequest& grantRequest) +{ + int32_t seqid = send_refresh_privileges(objToRefresh, authorizer, grantRequest); + recv_refresh_privileges(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_refresh_privileges(const HiveObjectRef& objToRefresh, const std::string& authorizer, const GrantRevokePrivilegeRequest& grantRequest) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("refresh_privileges", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_refresh_privileges_pargs args; + args.objToRefresh = &objToRefresh; + args.authorizer = &authorizer; + args.grantRequest = &grantRequest; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_refresh_privileges(GrantRevokePrivilegeResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("refresh_privileges") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_refresh_privileges_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "refresh_privileges failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::set_ugi(std::vector & _return, const std::string& user_name, const std::vector & group_names) +{ + int32_t seqid = send_set_ugi(user_name, group_names); + recv_set_ugi(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_set_ugi(const std::string& user_name, const std::vector & group_names) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("set_ugi", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_set_ugi_pargs args; + args.user_name = &user_name; + args.group_names = &group_names; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_set_ugi(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("set_ugi") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_set_ugi_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "set_ugi failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_delegation_token(std::string& _return, const std::string& token_owner, const std::string& renewer_kerberos_principal_name) +{ + int32_t seqid = send_get_delegation_token(token_owner, renewer_kerberos_principal_name); + recv_get_delegation_token(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_delegation_token(const std::string& token_owner, const std::string& renewer_kerberos_principal_name) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_delegation_token", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_delegation_token_pargs args; + args.token_owner = &token_owner; + args.renewer_kerberos_principal_name = &renewer_kerberos_principal_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_delegation_token(std::string& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_delegation_token") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_delegation_token_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_delegation_token failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +int64_t ThriftHiveMetastoreConcurrentClient::renew_delegation_token(const std::string& token_str_form) +{ + int32_t seqid = send_renew_delegation_token(token_str_form); + return recv_renew_delegation_token(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_renew_delegation_token(const std::string& token_str_form) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("renew_delegation_token", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_renew_delegation_token_pargs args; + args.token_str_form = &token_str_form; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +int64_t ThriftHiveMetastoreConcurrentClient::recv_renew_delegation_token(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("renew_delegation_token") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + int64_t _return; + ThriftHiveMetastore_renew_delegation_token_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "renew_delegation_token failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::cancel_delegation_token(const std::string& token_str_form) +{ + int32_t seqid = send_cancel_delegation_token(token_str_form); + recv_cancel_delegation_token(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_cancel_delegation_token(const std::string& token_str_form) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("cancel_delegation_token", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_cancel_delegation_token_pargs args; + args.token_str_form = &token_str_form; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_cancel_delegation_token(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("cancel_delegation_token") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_cancel_delegation_token_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::add_token(const std::string& token_identifier, const std::string& delegation_token) +{ + int32_t seqid = send_add_token(token_identifier, delegation_token); + return recv_add_token(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_add_token(const std::string& token_identifier, const std::string& delegation_token) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("add_token", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_token_pargs args; + args.token_identifier = &token_identifier; + args.delegation_token = &delegation_token; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_add_token(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_token") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_add_token_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "add_token failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::remove_token(const std::string& token_identifier) +{ + int32_t seqid = send_remove_token(token_identifier); + return recv_remove_token(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_remove_token(const std::string& token_identifier) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("remove_token", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_remove_token_pargs args; + args.token_identifier = &token_identifier; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_remove_token(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("remove_token") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_remove_token_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "remove_token failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_token(std::string& _return, const std::string& token_identifier) +{ + int32_t seqid = send_get_token(token_identifier); + recv_get_token(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_token(const std::string& token_identifier) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_token", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_token_pargs args; + args.token_identifier = &token_identifier; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_token(std::string& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_token") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_token_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_token failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_all_token_identifiers(std::vector & _return) +{ + int32_t seqid = send_get_all_token_identifiers(); + recv_get_all_token_identifiers(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_token_identifiers() +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_all_token_identifiers", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_all_token_identifiers_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_all_token_identifiers(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_all_token_identifiers") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_all_token_identifiers_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_token_identifiers failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +int32_t ThriftHiveMetastoreConcurrentClient::add_master_key(const std::string& key) +{ + int32_t seqid = send_add_master_key(key); + return recv_add_master_key(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_add_master_key(const std::string& key) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("add_master_key", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_master_key_pargs args; + args.key = &key; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +int32_t ThriftHiveMetastoreConcurrentClient::recv_add_master_key(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_master_key") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + int32_t _return; + ThriftHiveMetastore_add_master_key_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "add_master_key failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::update_master_key(const int32_t seq_number, const std::string& key) +{ + int32_t seqid = send_update_master_key(seq_number, key); + recv_update_master_key(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_update_master_key(const int32_t seq_number, const std::string& key) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("update_master_key", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_update_master_key_pargs args; + args.seq_number = &seq_number; + args.key = &key; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_update_master_key(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("update_master_key") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_update_master_key_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::remove_master_key(const int32_t key_seq) +{ + int32_t seqid = send_remove_master_key(key_seq); + return recv_remove_master_key(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_remove_master_key(const int32_t key_seq) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("remove_master_key", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_remove_master_key_pargs args; + args.key_seq = &key_seq; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_remove_master_key(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("remove_master_key") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_remove_master_key_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "remove_master_key failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_master_keys(std::vector & _return) +{ + int32_t seqid = send_get_master_keys(); + recv_get_master_keys(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_master_keys() +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_master_keys", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_master_keys_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_master_keys(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_master_keys") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_master_keys_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_master_keys failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_open_txns(GetOpenTxnsResponse& _return) +{ + int32_t seqid = send_get_open_txns(); + recv_get_open_txns(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_open_txns() +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_open_txns", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_open_txns_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_open_txns(GetOpenTxnsResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_open_txns") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_open_txns_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_open_txns failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_open_txns_info(GetOpenTxnsInfoResponse& _return) +{ + int32_t seqid = send_get_open_txns_info(); + recv_get_open_txns_info(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_open_txns_info() +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_open_txns_info", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_open_txns_info_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_open_txns_info(GetOpenTxnsInfoResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_open_txns_info") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_open_txns_info_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_open_txns_info failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::open_txns(OpenTxnsResponse& _return, const OpenTxnRequest& rqst) +{ + int32_t seqid = send_open_txns(rqst); + recv_open_txns(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_open_txns(const OpenTxnRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("open_txns", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_open_txns_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_open_txns(OpenTxnsResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("open_txns") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_open_txns_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "open_txns failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::abort_txn(const AbortTxnRequest& rqst) +{ + int32_t seqid = send_abort_txn(rqst); + recv_abort_txn(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_abort_txn(const AbortTxnRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("abort_txn", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_abort_txn_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_abort_txn(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("abort_txn") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_abort_txn_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::abort_txns(const AbortTxnsRequest& rqst) +{ + int32_t seqid = send_abort_txns(rqst); + recv_abort_txns(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_abort_txns(const AbortTxnsRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("abort_txns", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_abort_txns_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_abort_txns(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("abort_txns") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_abort_txns_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::commit_txn(const CommitTxnRequest& rqst) +{ + int32_t seqid = send_commit_txn(rqst); + recv_commit_txn(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_commit_txn(const CommitTxnRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("commit_txn", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_commit_txn_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_commit_txn(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("commit_txn") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_commit_txn_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +int64_t ThriftHiveMetastoreConcurrentClient::get_latest_txnid_in_conflict(const int64_t txnId) +{ + int32_t seqid = send_get_latest_txnid_in_conflict(txnId); + return recv_get_latest_txnid_in_conflict(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_latest_txnid_in_conflict(const int64_t txnId) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_latest_txnid_in_conflict", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_latest_txnid_in_conflict_pargs args; + args.txnId = &txnId; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +int64_t ThriftHiveMetastoreConcurrentClient::recv_get_latest_txnid_in_conflict(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_latest_txnid_in_conflict") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + int64_t _return; + ThriftHiveMetastore_get_latest_txnid_in_conflict_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_latest_txnid_in_conflict failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::repl_tbl_writeid_state(const ReplTblWriteIdStateRequest& rqst) +{ + int32_t seqid = send_repl_tbl_writeid_state(rqst); + recv_repl_tbl_writeid_state(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_repl_tbl_writeid_state(const ReplTblWriteIdStateRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("repl_tbl_writeid_state", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_repl_tbl_writeid_state_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_repl_tbl_writeid_state(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("repl_tbl_writeid_state") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_repl_tbl_writeid_state_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_valid_write_ids(GetValidWriteIdsResponse& _return, const GetValidWriteIdsRequest& rqst) +{ + int32_t seqid = send_get_valid_write_ids(rqst); + recv_get_valid_write_ids(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_valid_write_ids(const GetValidWriteIdsRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_valid_write_ids", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_valid_write_ids_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_valid_write_ids(GetValidWriteIdsResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_valid_write_ids") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_valid_write_ids_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_valid_write_ids failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::add_write_ids_to_min_history(const int64_t txnId, const std::map & writeIds) +{ + int32_t seqid = send_add_write_ids_to_min_history(txnId, writeIds); + recv_add_write_ids_to_min_history(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_add_write_ids_to_min_history(const int64_t txnId, const std::map & writeIds) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("add_write_ids_to_min_history", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_write_ids_to_min_history_pargs args; + args.txnId = &txnId; + args.writeIds = &writeIds; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_add_write_ids_to_min_history(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_write_ids_to_min_history") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_add_write_ids_to_min_history_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::allocate_table_write_ids(AllocateTableWriteIdsResponse& _return, const AllocateTableWriteIdsRequest& rqst) +{ + int32_t seqid = send_allocate_table_write_ids(rqst); + recv_allocate_table_write_ids(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_allocate_table_write_ids(const AllocateTableWriteIdsRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("allocate_table_write_ids", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_allocate_table_write_ids_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_allocate_table_write_ids(AllocateTableWriteIdsResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("allocate_table_write_ids") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_allocate_table_write_ids_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "allocate_table_write_ids failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_max_allocated_table_write_id(MaxAllocatedTableWriteIdResponse& _return, const MaxAllocatedTableWriteIdRequest& rqst) +{ + int32_t seqid = send_get_max_allocated_table_write_id(rqst); + recv_get_max_allocated_table_write_id(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_max_allocated_table_write_id(const MaxAllocatedTableWriteIdRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_max_allocated_table_write_id", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_max_allocated_table_write_id_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_max_allocated_table_write_id(MaxAllocatedTableWriteIdResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_max_allocated_table_write_id") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_max_allocated_table_write_id_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_max_allocated_table_write_id failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::seed_write_id(const SeedTableWriteIdsRequest& rqst) +{ + int32_t seqid = send_seed_write_id(rqst); + recv_seed_write_id(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_seed_write_id(const SeedTableWriteIdsRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("seed_write_id", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_seed_write_id_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_seed_write_id(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("seed_write_id") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_seed_write_id_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::seed_txn_id(const SeedTxnIdRequest& rqst) +{ + int32_t seqid = send_seed_txn_id(rqst); + recv_seed_txn_id(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_seed_txn_id(const SeedTxnIdRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("seed_txn_id", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_seed_txn_id_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_seed_txn_id(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("seed_txn_id") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_seed_txn_id_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::lock(LockResponse& _return, const LockRequest& rqst) +{ + int32_t seqid = send_lock(rqst); + recv_lock(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_lock(const LockRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("lock", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_lock_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_lock(LockResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("lock") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_lock_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "lock failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::check_lock(LockResponse& _return, const CheckLockRequest& rqst) +{ + int32_t seqid = send_check_lock(rqst); + recv_check_lock(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_check_lock(const CheckLockRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("check_lock", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_check_lock_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_check_lock(LockResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("check_lock") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_check_lock_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "check_lock failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::unlock(const UnlockRequest& rqst) +{ + int32_t seqid = send_unlock(rqst); + recv_unlock(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_unlock(const UnlockRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("unlock", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_unlock_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_unlock(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("unlock") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_unlock_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::show_locks(ShowLocksResponse& _return, const ShowLocksRequest& rqst) +{ + int32_t seqid = send_show_locks(rqst); + recv_show_locks(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_show_locks(const ShowLocksRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("show_locks", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_show_locks_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_show_locks(ShowLocksResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("show_locks") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_show_locks_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "show_locks failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::heartbeat(const HeartbeatRequest& ids) +{ + int32_t seqid = send_heartbeat(ids); + recv_heartbeat(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_heartbeat(const HeartbeatRequest& ids) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("heartbeat", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_heartbeat_pargs args; + args.ids = &ids; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_heartbeat(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("heartbeat") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_heartbeat_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const HeartbeatTxnRangeRequest& txns) +{ + int32_t seqid = send_heartbeat_txn_range(txns); + recv_heartbeat_txn_range(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_heartbeat_txn_range(const HeartbeatTxnRangeRequest& txns) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("heartbeat_txn_range", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_heartbeat_txn_range_pargs args; + args.txns = &txns; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("heartbeat_txn_range") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_heartbeat_txn_range_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "heartbeat_txn_range failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::compact(const CompactionRequest& rqst) +{ + int32_t seqid = send_compact(rqst); + recv_compact(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_compact(const CompactionRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("compact", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_compact_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_compact(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("compact") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_compact_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::compact2(CompactionResponse& _return, const CompactionRequest& rqst) +{ + int32_t seqid = send_compact2(rqst); + recv_compact2(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_compact2(const CompactionRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("compact2", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_compact2_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_compact2(CompactionResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("compact2") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_compact2_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "compact2 failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst) +{ + int32_t seqid = send_show_compact(rqst); + recv_show_compact(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_show_compact(const ShowCompactRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("show_compact", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_show_compact_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_show_compact(ShowCompactResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("show_compact") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_show_compact_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "show_compact failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::submit_for_cleanup(const CompactionRequest& o1, const int64_t o2, const int64_t o3) +{ + int32_t seqid = send_submit_for_cleanup(o1, o2, o3); + return recv_submit_for_cleanup(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_submit_for_cleanup(const CompactionRequest& o1, const int64_t o2, const int64_t o3) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("submit_for_cleanup", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_submit_for_cleanup_pargs args; + args.o1 = &o1; + args.o2 = &o2; + args.o3 = &o3; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_submit_for_cleanup(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("submit_for_cleanup") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_submit_for_cleanup_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "submit_for_cleanup failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::add_dynamic_partitions(const AddDynamicPartitions& rqst) +{ + int32_t seqid = send_add_dynamic_partitions(rqst); + recv_add_dynamic_partitions(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_add_dynamic_partitions(const AddDynamicPartitions& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("add_dynamic_partitions", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_dynamic_partitions_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_add_dynamic_partitions(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_dynamic_partitions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_add_dynamic_partitions_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::find_next_compact(OptionalCompactionInfoStruct& _return, const std::string& workerId) +{ + int32_t seqid = send_find_next_compact(workerId); + recv_find_next_compact(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_find_next_compact(const std::string& workerId) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("find_next_compact", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_find_next_compact_pargs args; + args.workerId = &workerId; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_find_next_compact(OptionalCompactionInfoStruct& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("find_next_compact") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_find_next_compact_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "find_next_compact failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::find_next_compact2(OptionalCompactionInfoStruct& _return, const FindNextCompactRequest& rqst) +{ + int32_t seqid = send_find_next_compact2(rqst); + recv_find_next_compact2(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_find_next_compact2(const FindNextCompactRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("find_next_compact2", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_find_next_compact2_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_find_next_compact2(OptionalCompactionInfoStruct& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("find_next_compact2") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_find_next_compact2_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "find_next_compact2 failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::update_compactor_state(const CompactionInfoStruct& cr, const int64_t txn_id) +{ + int32_t seqid = send_update_compactor_state(cr, txn_id); + recv_update_compactor_state(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_update_compactor_state(const CompactionInfoStruct& cr, const int64_t txn_id) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("update_compactor_state", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_update_compactor_state_pargs args; + args.cr = &cr; + args.txn_id = &txn_id; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_update_compactor_state(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("update_compactor_state") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_update_compactor_state_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::find_columns_with_stats(std::vector & _return, const CompactionInfoStruct& cr) +{ + int32_t seqid = send_find_columns_with_stats(cr); + recv_find_columns_with_stats(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_find_columns_with_stats(const CompactionInfoStruct& cr) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("find_columns_with_stats", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_find_columns_with_stats_pargs args; + args.cr = &cr; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_find_columns_with_stats(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("find_columns_with_stats") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_find_columns_with_stats_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "find_columns_with_stats failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::mark_cleaned(const CompactionInfoStruct& cr) +{ + int32_t seqid = send_mark_cleaned(cr); + recv_mark_cleaned(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_mark_cleaned(const CompactionInfoStruct& cr) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("mark_cleaned", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_mark_cleaned_pargs args; + args.cr = &cr; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_mark_cleaned(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("mark_cleaned") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_mark_cleaned_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::mark_compacted(const CompactionInfoStruct& cr) +{ + int32_t seqid = send_mark_compacted(cr); + recv_mark_compacted(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_mark_compacted(const CompactionInfoStruct& cr) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("mark_compacted", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_mark_compacted_pargs args; + args.cr = &cr; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_mark_compacted(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("mark_compacted") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_mark_compacted_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::mark_failed(const CompactionInfoStruct& cr) +{ + int32_t seqid = send_mark_failed(cr); + recv_mark_failed(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_mark_failed(const CompactionInfoStruct& cr) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("mark_failed", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_mark_failed_pargs args; + args.cr = &cr; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_mark_failed(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("mark_failed") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_mark_failed_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::mark_refused(const CompactionInfoStruct& cr) +{ + int32_t seqid = send_mark_refused(cr); + recv_mark_refused(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_mark_refused(const CompactionInfoStruct& cr) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("mark_refused", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_mark_refused_pargs args; + args.cr = &cr; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_mark_refused(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("mark_refused") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_mark_refused_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::update_compaction_metrics_data(const CompactionMetricsDataStruct& data) +{ + int32_t seqid = send_update_compaction_metrics_data(data); + return recv_update_compaction_metrics_data(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_update_compaction_metrics_data(const CompactionMetricsDataStruct& data) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("update_compaction_metrics_data", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_update_compaction_metrics_data_pargs args; + args.data = &data; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_update_compaction_metrics_data(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("update_compaction_metrics_data") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_update_compaction_metrics_data_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "update_compaction_metrics_data failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::remove_compaction_metrics_data(const CompactionMetricsDataRequest& request) +{ + int32_t seqid = send_remove_compaction_metrics_data(request); + recv_remove_compaction_metrics_data(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_remove_compaction_metrics_data(const CompactionMetricsDataRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("remove_compaction_metrics_data", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_remove_compaction_metrics_data_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_remove_compaction_metrics_data(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("remove_compaction_metrics_data") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_remove_compaction_metrics_data_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::set_hadoop_jobid(const std::string& jobId, const int64_t cq_id) +{ + int32_t seqid = send_set_hadoop_jobid(jobId, cq_id); + recv_set_hadoop_jobid(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_set_hadoop_jobid(const std::string& jobId, const int64_t cq_id) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("set_hadoop_jobid", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_set_hadoop_jobid_pargs args; + args.jobId = &jobId; + args.cq_id = &cq_id; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_set_hadoop_jobid(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("set_hadoop_jobid") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_set_hadoop_jobid_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_latest_committed_compaction_info(GetLatestCommittedCompactionInfoResponse& _return, const GetLatestCommittedCompactionInfoRequest& rqst) +{ + int32_t seqid = send_get_latest_committed_compaction_info(rqst); + recv_get_latest_committed_compaction_info(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_latest_committed_compaction_info(const GetLatestCommittedCompactionInfoRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_latest_committed_compaction_info", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_latest_committed_compaction_info_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_latest_committed_compaction_info(GetLatestCommittedCompactionInfoResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_latest_committed_compaction_info") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_latest_committed_compaction_info_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_latest_committed_compaction_info failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_next_notification(NotificationEventResponse& _return, const NotificationEventRequest& rqst) +{ + int32_t seqid = send_get_next_notification(rqst); + recv_get_next_notification(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_next_notification(const NotificationEventRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_next_notification", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_next_notification_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_next_notification(NotificationEventResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_next_notification") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_next_notification_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_next_notification failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_current_notificationEventId(CurrentNotificationEventId& _return) +{ + int32_t seqid = send_get_current_notificationEventId(); + recv_get_current_notificationEventId(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_current_notificationEventId() +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_current_notificationEventId", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_current_notificationEventId_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_current_notificationEventId(CurrentNotificationEventId& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_current_notificationEventId") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_current_notificationEventId_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_current_notificationEventId failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_notification_events_count(NotificationEventsCountResponse& _return, const NotificationEventsCountRequest& rqst) +{ + int32_t seqid = send_get_notification_events_count(rqst); + recv_get_notification_events_count(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_notification_events_count(const NotificationEventsCountRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_notification_events_count", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_notification_events_count_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_notification_events_count(NotificationEventsCountResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_notification_events_count") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_notification_events_count_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_notification_events_count failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::fire_listener_event(FireEventResponse& _return, const FireEventRequest& rqst) +{ + int32_t seqid = send_fire_listener_event(rqst); + recv_fire_listener_event(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_fire_listener_event(const FireEventRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("fire_listener_event", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_fire_listener_event_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_fire_listener_event(FireEventResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("fire_listener_event") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_fire_listener_event_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "fire_listener_event failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::flushCache() +{ + int32_t seqid = send_flushCache(); + recv_flushCache(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_flushCache() +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("flushCache", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_flushCache_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_flushCache(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("flushCache") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_flushCache_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::add_write_notification_log(WriteNotificationLogResponse& _return, const WriteNotificationLogRequest& rqst) +{ + int32_t seqid = send_add_write_notification_log(rqst); + recv_add_write_notification_log(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_add_write_notification_log(const WriteNotificationLogRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("add_write_notification_log", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_write_notification_log_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_add_write_notification_log(WriteNotificationLogResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_write_notification_log") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_add_write_notification_log_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "add_write_notification_log failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::add_write_notification_log_in_batch(WriteNotificationLogBatchResponse& _return, const WriteNotificationLogBatchRequest& rqst) +{ + int32_t seqid = send_add_write_notification_log_in_batch(rqst); + recv_add_write_notification_log_in_batch(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_add_write_notification_log_in_batch(const WriteNotificationLogBatchRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("add_write_notification_log_in_batch", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_write_notification_log_in_batch_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_add_write_notification_log_in_batch(WriteNotificationLogBatchResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_write_notification_log_in_batch") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_add_write_notification_log_in_batch_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "add_write_notification_log_in_batch failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::cm_recycle(CmRecycleResponse& _return, const CmRecycleRequest& request) +{ + int32_t seqid = send_cm_recycle(request); + recv_cm_recycle(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_cm_recycle(const CmRecycleRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("cm_recycle", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_cm_recycle_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_cm_recycle(CmRecycleResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("cm_recycle") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_cm_recycle_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "cm_recycle failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req) +{ + int32_t seqid = send_get_file_metadata_by_expr(req); + recv_get_file_metadata_by_expr(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_file_metadata_by_expr(const GetFileMetadataByExprRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_file_metadata_by_expr", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_file_metadata_by_expr_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_file_metadata_by_expr") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_file_metadata_by_expr_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_file_metadata_by_expr failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_file_metadata(GetFileMetadataResult& _return, const GetFileMetadataRequest& req) +{ + int32_t seqid = send_get_file_metadata(req); + recv_get_file_metadata(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_file_metadata(const GetFileMetadataRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_file_metadata", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_file_metadata_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_file_metadata(GetFileMetadataResult& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_file_metadata") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_file_metadata_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_file_metadata failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::put_file_metadata(PutFileMetadataResult& _return, const PutFileMetadataRequest& req) +{ + int32_t seqid = send_put_file_metadata(req); + recv_put_file_metadata(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_put_file_metadata(const PutFileMetadataRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("put_file_metadata", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_put_file_metadata_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_put_file_metadata(PutFileMetadataResult& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("put_file_metadata") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_put_file_metadata_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "put_file_metadata failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::clear_file_metadata(ClearFileMetadataResult& _return, const ClearFileMetadataRequest& req) +{ + int32_t seqid = send_clear_file_metadata(req); + recv_clear_file_metadata(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_clear_file_metadata(const ClearFileMetadataRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("clear_file_metadata", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_clear_file_metadata_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_clear_file_metadata(ClearFileMetadataResult& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("clear_file_metadata") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_clear_file_metadata_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "clear_file_metadata failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::cache_file_metadata(CacheFileMetadataResult& _return, const CacheFileMetadataRequest& req) +{ + int32_t seqid = send_cache_file_metadata(req); + recv_cache_file_metadata(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_cache_file_metadata(const CacheFileMetadataRequest& req) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("cache_file_metadata", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_cache_file_metadata_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_cache_file_metadata(CacheFileMetadataResult& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("cache_file_metadata") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_cache_file_metadata_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "cache_file_metadata failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_metastore_db_uuid(std::string& _return) +{ + int32_t seqid = send_get_metastore_db_uuid(); + recv_get_metastore_db_uuid(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_metastore_db_uuid() +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_metastore_db_uuid", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_metastore_db_uuid_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_metastore_db_uuid(std::string& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_metastore_db_uuid") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_metastore_db_uuid_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_metastore_db_uuid failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::create_resource_plan(WMCreateResourcePlanResponse& _return, const WMCreateResourcePlanRequest& request) +{ + int32_t seqid = send_create_resource_plan(request); + recv_create_resource_plan(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_create_resource_plan(const WMCreateResourcePlanRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("create_resource_plan", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_resource_plan_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_create_resource_plan(WMCreateResourcePlanResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_resource_plan") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_create_resource_plan_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "create_resource_plan failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_resource_plan(WMGetResourcePlanResponse& _return, const WMGetResourcePlanRequest& request) +{ + int32_t seqid = send_get_resource_plan(request); + recv_get_resource_plan(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_resource_plan(const WMGetResourcePlanRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_resource_plan", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_resource_plan_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_resource_plan(WMGetResourcePlanResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_resource_plan") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_resource_plan_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_resource_plan failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_active_resource_plan(WMGetActiveResourcePlanResponse& _return, const WMGetActiveResourcePlanRequest& request) +{ + int32_t seqid = send_get_active_resource_plan(request); + recv_get_active_resource_plan(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_active_resource_plan(const WMGetActiveResourcePlanRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_active_resource_plan", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_active_resource_plan_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_active_resource_plan(WMGetActiveResourcePlanResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_active_resource_plan") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_active_resource_plan_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_active_resource_plan failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_all_resource_plans(WMGetAllResourcePlanResponse& _return, const WMGetAllResourcePlanRequest& request) +{ + int32_t seqid = send_get_all_resource_plans(request); + recv_get_all_resource_plans(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_resource_plans(const WMGetAllResourcePlanRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_all_resource_plans", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_all_resource_plans_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_all_resource_plans(WMGetAllResourcePlanResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_all_resource_plans") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_all_resource_plans_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_resource_plans failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::alter_resource_plan(WMAlterResourcePlanResponse& _return, const WMAlterResourcePlanRequest& request) +{ + int32_t seqid = send_alter_resource_plan(request); + recv_alter_resource_plan(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_resource_plan(const WMAlterResourcePlanRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("alter_resource_plan", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_resource_plan_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_alter_resource_plan(WMAlterResourcePlanResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_resource_plan") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_alter_resource_plan_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "alter_resource_plan failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::validate_resource_plan(WMValidateResourcePlanResponse& _return, const WMValidateResourcePlanRequest& request) +{ + int32_t seqid = send_validate_resource_plan(request); + recv_validate_resource_plan(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_validate_resource_plan(const WMValidateResourcePlanRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("validate_resource_plan", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_validate_resource_plan_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_validate_resource_plan(WMValidateResourcePlanResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("validate_resource_plan") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_validate_resource_plan_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "validate_resource_plan failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::drop_resource_plan(WMDropResourcePlanResponse& _return, const WMDropResourcePlanRequest& request) +{ + int32_t seqid = send_drop_resource_plan(request); + recv_drop_resource_plan(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_resource_plan(const WMDropResourcePlanRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_resource_plan", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_resource_plan_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_drop_resource_plan(WMDropResourcePlanResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_resource_plan") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_drop_resource_plan_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_resource_plan failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::create_wm_trigger(WMCreateTriggerResponse& _return, const WMCreateTriggerRequest& request) +{ + int32_t seqid = send_create_wm_trigger(request); + recv_create_wm_trigger(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_create_wm_trigger(const WMCreateTriggerRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("create_wm_trigger", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_wm_trigger_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_create_wm_trigger(WMCreateTriggerResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_wm_trigger") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_create_wm_trigger_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "create_wm_trigger failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::alter_wm_trigger(WMAlterTriggerResponse& _return, const WMAlterTriggerRequest& request) +{ + int32_t seqid = send_alter_wm_trigger(request); + recv_alter_wm_trigger(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_wm_trigger(const WMAlterTriggerRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("alter_wm_trigger", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_wm_trigger_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_alter_wm_trigger(WMAlterTriggerResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_wm_trigger") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_alter_wm_trigger_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "alter_wm_trigger failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::drop_wm_trigger(WMDropTriggerResponse& _return, const WMDropTriggerRequest& request) +{ + int32_t seqid = send_drop_wm_trigger(request); + recv_drop_wm_trigger(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_wm_trigger(const WMDropTriggerRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_wm_trigger", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_wm_trigger_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_drop_wm_trigger(WMDropTriggerResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_wm_trigger") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_drop_wm_trigger_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_wm_trigger failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const WMGetTriggersForResourePlanRequest& request) +{ + int32_t seqid = send_get_triggers_for_resourceplan(request); + recv_get_triggers_for_resourceplan(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_triggers_for_resourceplan(const WMGetTriggersForResourePlanRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_triggers_for_resourceplan", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_triggers_for_resourceplan_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_triggers_for_resourceplan") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_triggers_for_resourceplan_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_triggers_for_resourceplan failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::create_wm_pool(WMCreatePoolResponse& _return, const WMCreatePoolRequest& request) +{ + int32_t seqid = send_create_wm_pool(request); + recv_create_wm_pool(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_create_wm_pool(const WMCreatePoolRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("create_wm_pool", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_wm_pool_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_create_wm_pool(WMCreatePoolResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_wm_pool") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_create_wm_pool_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "create_wm_pool failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::alter_wm_pool(WMAlterPoolResponse& _return, const WMAlterPoolRequest& request) +{ + int32_t seqid = send_alter_wm_pool(request); + recv_alter_wm_pool(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_wm_pool(const WMAlterPoolRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("alter_wm_pool", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_wm_pool_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_alter_wm_pool(WMAlterPoolResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_wm_pool") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_alter_wm_pool_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "alter_wm_pool failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::drop_wm_pool(WMDropPoolResponse& _return, const WMDropPoolRequest& request) +{ + int32_t seqid = send_drop_wm_pool(request); + recv_drop_wm_pool(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_wm_pool(const WMDropPoolRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_wm_pool", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_wm_pool_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_drop_wm_pool(WMDropPoolResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_wm_pool") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_drop_wm_pool_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_wm_pool failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const WMCreateOrUpdateMappingRequest& request) +{ + int32_t seqid = send_create_or_update_wm_mapping(request); + recv_create_or_update_wm_mapping(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_create_or_update_wm_mapping(const WMCreateOrUpdateMappingRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("create_or_update_wm_mapping", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_or_update_wm_mapping_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_or_update_wm_mapping") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_create_or_update_wm_mapping_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "create_or_update_wm_mapping failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::drop_wm_mapping(WMDropMappingResponse& _return, const WMDropMappingRequest& request) +{ + int32_t seqid = send_drop_wm_mapping(request); + recv_drop_wm_mapping(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_wm_mapping(const WMDropMappingRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_wm_mapping", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_wm_mapping_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_drop_wm_mapping(WMDropMappingResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_wm_mapping") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_drop_wm_mapping_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_wm_mapping failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return, const WMCreateOrDropTriggerToPoolMappingRequest& request) +{ + int32_t seqid = send_create_or_drop_wm_trigger_to_pool_mapping(request); + recv_create_or_drop_wm_trigger_to_pool_mapping(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_create_or_drop_wm_trigger_to_pool_mapping(const WMCreateOrDropTriggerToPoolMappingRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("create_or_drop_wm_trigger_to_pool_mapping", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_or_drop_wm_trigger_to_pool_mapping") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "create_or_drop_wm_trigger_to_pool_mapping failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::create_ischema(const ISchema& schema) +{ + int32_t seqid = send_create_ischema(schema); + recv_create_ischema(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_create_ischema(const ISchema& schema) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("create_ischema", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_ischema_pargs args; + args.schema = &schema; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_create_ischema(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_ischema") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_create_ischema_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::alter_ischema(const AlterISchemaRequest& rqst) +{ + int32_t seqid = send_alter_ischema(rqst); + recv_alter_ischema(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_ischema(const AlterISchemaRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("alter_ischema", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_ischema_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_alter_ischema(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("alter_ischema") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_alter_ischema_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_ischema(ISchema& _return, const ISchemaName& name) +{ + int32_t seqid = send_get_ischema(name); + recv_get_ischema(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_ischema(const ISchemaName& name) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_ischema", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_ischema_pargs args; + args.name = &name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_ischema(ISchema& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_ischema") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_ischema_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_ischema failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::drop_ischema(const ISchemaName& name) +{ + int32_t seqid = send_drop_ischema(name); + recv_drop_ischema(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_ischema(const ISchemaName& name) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_ischema", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_ischema_pargs args; + args.name = &name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_drop_ischema(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_ischema") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_drop_ischema_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::add_schema_version(const SchemaVersion& schemaVersion) +{ + int32_t seqid = send_add_schema_version(schemaVersion); + recv_add_schema_version(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_add_schema_version(const SchemaVersion& schemaVersion) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("add_schema_version", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_schema_version_pargs args; + args.schemaVersion = &schemaVersion; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_add_schema_version(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_schema_version") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_add_schema_version_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_schema_version(SchemaVersion& _return, const SchemaVersionDescriptor& schemaVersion) +{ + int32_t seqid = send_get_schema_version(schemaVersion); + recv_get_schema_version(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_schema_version(const SchemaVersionDescriptor& schemaVersion) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_schema_version", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_schema_version_pargs args; + args.schemaVersion = &schemaVersion; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_schema_version(SchemaVersion& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_schema_version") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_schema_version_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_schema_version failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_schema_latest_version(SchemaVersion& _return, const ISchemaName& schemaName) +{ + int32_t seqid = send_get_schema_latest_version(schemaName); + recv_get_schema_latest_version(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_schema_latest_version(const ISchemaName& schemaName) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_schema_latest_version", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_schema_latest_version_pargs args; + args.schemaName = &schemaName; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_schema_latest_version(SchemaVersion& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_schema_latest_version") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_schema_latest_version_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_schema_latest_version failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_schema_all_versions(std::vector & _return, const ISchemaName& schemaName) +{ + int32_t seqid = send_get_schema_all_versions(schemaName); + recv_get_schema_all_versions(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_schema_all_versions(const ISchemaName& schemaName) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_schema_all_versions", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_schema_all_versions_pargs args; + args.schemaName = &schemaName; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_schema_all_versions(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_schema_all_versions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_schema_all_versions_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_schema_all_versions failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::drop_schema_version(const SchemaVersionDescriptor& schemaVersion) +{ + int32_t seqid = send_drop_schema_version(schemaVersion); + recv_drop_schema_version(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_schema_version(const SchemaVersionDescriptor& schemaVersion) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_schema_version", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_schema_version_pargs args; + args.schemaVersion = &schemaVersion; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_drop_schema_version(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_schema_version") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_drop_schema_version_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_schemas_by_cols(FindSchemasByColsResp& _return, const FindSchemasByColsRqst& rqst) +{ + int32_t seqid = send_get_schemas_by_cols(rqst); + recv_get_schemas_by_cols(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_schemas_by_cols(const FindSchemasByColsRqst& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_schemas_by_cols", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_schemas_by_cols_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_schemas_by_cols(FindSchemasByColsResp& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_schemas_by_cols") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_schemas_by_cols_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_schemas_by_cols failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::map_schema_version_to_serde(const MapSchemaVersionToSerdeRequest& rqst) +{ + int32_t seqid = send_map_schema_version_to_serde(rqst); + recv_map_schema_version_to_serde(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_map_schema_version_to_serde(const MapSchemaVersionToSerdeRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("map_schema_version_to_serde", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_map_schema_version_to_serde_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_map_schema_version_to_serde(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("map_schema_version_to_serde") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_map_schema_version_to_serde_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::set_schema_version_state(const SetSchemaVersionStateRequest& rqst) +{ + int32_t seqid = send_set_schema_version_state(rqst); + recv_set_schema_version_state(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_set_schema_version_state(const SetSchemaVersionStateRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("set_schema_version_state", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_set_schema_version_state_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_set_schema_version_state(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("set_schema_version_state") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_set_schema_version_state_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::add_serde(const SerDeInfo& serde) +{ + int32_t seqid = send_add_serde(serde); + recv_add_serde(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_add_serde(const SerDeInfo& serde) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("add_serde", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_serde_pargs args; + args.serde = &serde; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_add_serde(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_serde") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_add_serde_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_serde(SerDeInfo& _return, const GetSerdeRequest& rqst) +{ + int32_t seqid = send_get_serde(rqst); + recv_get_serde(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_serde(const GetSerdeRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_serde", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_serde_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_serde(SerDeInfo& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_serde") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_serde_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_serde failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_lock_materialization_rebuild(LockResponse& _return, const std::string& dbName, const std::string& tableName, const int64_t txnId) +{ + int32_t seqid = send_get_lock_materialization_rebuild(dbName, tableName, txnId); + recv_get_lock_materialization_rebuild(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_lock_materialization_rebuild(const std::string& dbName, const std::string& tableName, const int64_t txnId) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_lock_materialization_rebuild", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_lock_materialization_rebuild_pargs args; + args.dbName = &dbName; + args.tableName = &tableName; + args.txnId = &txnId; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_lock_materialization_rebuild(LockResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_lock_materialization_rebuild") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_lock_materialization_rebuild_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_lock_materialization_rebuild failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +bool ThriftHiveMetastoreConcurrentClient::heartbeat_lock_materialization_rebuild(const std::string& dbName, const std::string& tableName, const int64_t txnId) +{ + int32_t seqid = send_heartbeat_lock_materialization_rebuild(dbName, tableName, txnId); + return recv_heartbeat_lock_materialization_rebuild(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_heartbeat_lock_materialization_rebuild(const std::string& dbName, const std::string& tableName, const int64_t txnId) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("heartbeat_lock_materialization_rebuild", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_pargs args; + args.dbName = &dbName; + args.tableName = &tableName; + args.txnId = &txnId; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_heartbeat_lock_materialization_rebuild(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("heartbeat_lock_materialization_rebuild") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "heartbeat_lock_materialization_rebuild failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::add_runtime_stats(const RuntimeStat& stat) +{ + int32_t seqid = send_add_runtime_stats(stat); + recv_add_runtime_stats(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_add_runtime_stats(const RuntimeStat& stat) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("add_runtime_stats", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_runtime_stats_pargs args; + args.stat = &stat; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_add_runtime_stats(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_runtime_stats") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_add_runtime_stats_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_runtime_stats(std::vector & _return, const GetRuntimeStatsRequest& rqst) +{ + int32_t seqid = send_get_runtime_stats(rqst); + recv_get_runtime_stats(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_runtime_stats(const GetRuntimeStatsRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_runtime_stats", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_runtime_stats_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_runtime_stats(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_runtime_stats") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_runtime_stats_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_runtime_stats failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_partitions_with_specs(GetPartitionsResponse& _return, const GetPartitionsRequest& request) +{ + int32_t seqid = send_get_partitions_with_specs(request); + recv_get_partitions_with_specs(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_partitions_with_specs(const GetPartitionsRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_partitions_with_specs", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_partitions_with_specs_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_partitions_with_specs(GetPartitionsResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_partitions_with_specs") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_partitions_with_specs_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_partitions_with_specs failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::scheduled_query_poll(ScheduledQueryPollResponse& _return, const ScheduledQueryPollRequest& request) +{ + int32_t seqid = send_scheduled_query_poll(request); + recv_scheduled_query_poll(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_scheduled_query_poll(const ScheduledQueryPollRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("scheduled_query_poll", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_scheduled_query_poll_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_scheduled_query_poll(ScheduledQueryPollResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("scheduled_query_poll") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_scheduled_query_poll_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scheduled_query_poll failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::scheduled_query_maintenance(const ScheduledQueryMaintenanceRequest& request) +{ + int32_t seqid = send_scheduled_query_maintenance(request); + recv_scheduled_query_maintenance(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_scheduled_query_maintenance(const ScheduledQueryMaintenanceRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("scheduled_query_maintenance", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_scheduled_query_maintenance_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_scheduled_query_maintenance(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("scheduled_query_maintenance") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_scheduled_query_maintenance_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::scheduled_query_progress(const ScheduledQueryProgressInfo& info) +{ + int32_t seqid = send_scheduled_query_progress(info); + recv_scheduled_query_progress(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_scheduled_query_progress(const ScheduledQueryProgressInfo& info) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("scheduled_query_progress", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_scheduled_query_progress_pargs args; + args.info = &info; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_scheduled_query_progress(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("scheduled_query_progress") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_scheduled_query_progress_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_scheduled_query(ScheduledQuery& _return, const ScheduledQueryKey& scheduleKey) +{ + int32_t seqid = send_get_scheduled_query(scheduleKey); + recv_get_scheduled_query(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_scheduled_query(const ScheduledQueryKey& scheduleKey) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_scheduled_query", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_scheduled_query_pargs args; + args.scheduleKey = &scheduleKey; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_scheduled_query(ScheduledQuery& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_scheduled_query") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_scheduled_query_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_scheduled_query failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::add_replication_metrics(const ReplicationMetricList& replicationMetricList) +{ + int32_t seqid = send_add_replication_metrics(replicationMetricList); + recv_add_replication_metrics(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_add_replication_metrics(const ReplicationMetricList& replicationMetricList) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("add_replication_metrics", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_replication_metrics_pargs args; + args.replicationMetricList = &replicationMetricList; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_add_replication_metrics(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_replication_metrics") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_add_replication_metrics_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_replication_metrics(ReplicationMetricList& _return, const GetReplicationMetricsRequest& rqst) +{ + int32_t seqid = send_get_replication_metrics(rqst); + recv_get_replication_metrics(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_replication_metrics(const GetReplicationMetricsRequest& rqst) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_replication_metrics", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_replication_metrics_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_replication_metrics(ReplicationMetricList& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_replication_metrics") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_replication_metrics_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_replication_metrics failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_open_txns_req(GetOpenTxnsResponse& _return, const GetOpenTxnsRequest& getOpenTxnsRequest) +{ + int32_t seqid = send_get_open_txns_req(getOpenTxnsRequest); + recv_get_open_txns_req(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_open_txns_req(const GetOpenTxnsRequest& getOpenTxnsRequest) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_open_txns_req", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_open_txns_req_pargs args; + args.getOpenTxnsRequest = &getOpenTxnsRequest; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_open_txns_req(GetOpenTxnsResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_open_txns_req") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_open_txns_req_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_open_txns_req failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::create_stored_procedure(const StoredProcedure& proc) +{ + int32_t seqid = send_create_stored_procedure(proc); + recv_create_stored_procedure(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_create_stored_procedure(const StoredProcedure& proc) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("create_stored_procedure", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_stored_procedure_pargs args; + args.proc = &proc; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_create_stored_procedure(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("create_stored_procedure") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_create_stored_procedure_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_stored_procedure(StoredProcedure& _return, const StoredProcedureRequest& request) +{ + int32_t seqid = send_get_stored_procedure(request); + recv_get_stored_procedure(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_stored_procedure(const StoredProcedureRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_stored_procedure", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_stored_procedure_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_stored_procedure(StoredProcedure& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_stored_procedure") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_stored_procedure_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_stored_procedure failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::drop_stored_procedure(const StoredProcedureRequest& request) +{ + int32_t seqid = send_drop_stored_procedure(request); + recv_drop_stored_procedure(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_stored_procedure(const StoredProcedureRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_stored_procedure", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_stored_procedure_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_drop_stored_procedure(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_stored_procedure") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_drop_stored_procedure_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_all_stored_procedures(std::vector & _return, const ListStoredProcedureRequest& request) +{ + int32_t seqid = send_get_all_stored_procedures(request); + recv_get_all_stored_procedures(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_stored_procedures(const ListStoredProcedureRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_all_stored_procedures", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_all_stored_procedures_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_all_stored_procedures(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_all_stored_procedures") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_all_stored_procedures_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_stored_procedures failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::find_package(Package& _return, const GetPackageRequest& request) +{ + int32_t seqid = send_find_package(request); + recv_find_package(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_find_package(const GetPackageRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("find_package", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_find_package_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_find_package(Package& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("find_package") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_find_package_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "find_package failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::add_package(const AddPackageRequest& request) +{ + int32_t seqid = send_add_package(request); + recv_add_package(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_add_package(const AddPackageRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("add_package", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_package_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_add_package(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("add_package") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_add_package_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_all_packages(std::vector & _return, const ListPackageRequest& request) +{ + int32_t seqid = send_get_all_packages(request); + recv_get_all_packages(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_packages(const ListPackageRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_all_packages", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_all_packages_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_all_packages(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_all_packages") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_all_packages_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_packages failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::drop_package(const DropPackageRequest& request) +{ + int32_t seqid = send_drop_package(request); + recv_drop_package(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_package(const DropPackageRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("drop_package", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_package_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_drop_package(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("drop_package") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_drop_package_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_all_write_event_info(std::vector & _return, const GetAllWriteEventInfoRequest& request) +{ + int32_t seqid = send_get_all_write_event_info(request); + recv_get_all_write_event_info(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_write_event_info(const GetAllWriteEventInfoRequest& request) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_all_write_event_info", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_all_write_event_info_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_all_write_event_info(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_all_write_event_info") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_all_write_event_info_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_write_event_info failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +}}} // namespace + diff --git a/src/iceberg/catalog/hive/gen-cpp/ThriftHiveMetastore.h b/src/iceberg/catalog/hive/gen-cpp/ThriftHiveMetastore.h new file mode 100644 index 000000000..319a7a334 --- /dev/null +++ b/src/iceberg/catalog/hive/gen-cpp/ThriftHiveMetastore.h @@ -0,0 +1,35369 @@ +/** + * Autogenerated by Thrift Compiler (0.23.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef ThriftHiveMetastore_H +#define ThriftHiveMetastore_H + +#include +#include +#include +#include "hive_metastore_types.h" +#include "FacebookService.h" + +namespace Apache { namespace Hadoop { namespace Hive { + +#ifdef _MSC_VER + #pragma warning( push ) + #pragma warning (disable : 4250 ) //inheriting methods via dominance +#endif + +/** + * This interface is live. + */ +class ThriftHiveMetastoreIf : virtual public ::facebook::fb303::FacebookServiceIf { + public: + virtual ~ThriftHiveMetastoreIf() {} + virtual void abort_Compactions(AbortCompactResponse& _return, const AbortCompactionRequest& rqst) = 0; + virtual void getMetaConf(std::string& _return, const std::string& key) = 0; + virtual void setMetaConf(const std::string& key, const std::string& value) = 0; + virtual void create_catalog(const CreateCatalogRequest& catalog) = 0; + virtual void alter_catalog(const AlterCatalogRequest& rqst) = 0; + virtual void get_catalog(GetCatalogResponse& _return, const GetCatalogRequest& catName) = 0; + virtual void get_catalogs(GetCatalogsResponse& _return) = 0; + virtual void drop_catalog(const DropCatalogRequest& catName) = 0; + virtual void create_database(const Database& database) = 0; + virtual void create_database_req(const CreateDatabaseRequest& createDatabaseRequest) = 0; + virtual void get_database(Database& _return, const std::string& name) = 0; + virtual void get_database_req(Database& _return, const GetDatabaseRequest& request) = 0; + virtual void drop_database(const std::string& name, const bool deleteData, const bool cascade) = 0; + virtual void drop_database_req(const DropDatabaseRequest& req) = 0; + virtual void get_databases(std::vector & _return, const std::string& pattern) = 0; + virtual void get_all_databases(std::vector & _return) = 0; + virtual void alter_database(const std::string& dbname, const Database& db) = 0; + virtual void alter_database_req(const AlterDatabaseRequest& alterDbReq) = 0; + virtual void create_dataconnector_req(const CreateDataConnectorRequest& connectorReq) = 0; + virtual void get_dataconnector_req(DataConnector& _return, const GetDataConnectorRequest& request) = 0; + virtual void drop_dataconnector_req(const DropDataConnectorRequest& dropDcReq) = 0; + virtual void get_dataconnectors(std::vector & _return) = 0; + virtual void alter_dataconnector_req(const AlterDataConnectorRequest& alterReq) = 0; + virtual void get_type(Type& _return, const std::string& name) = 0; + virtual bool create_type(const Type& type) = 0; + virtual bool drop_type(const std::string& type) = 0; + virtual void get_type_all(std::map & _return, const std::string& name) = 0; + virtual void get_fields(std::vector & _return, const std::string& db_name, const std::string& table_name) = 0; + virtual void get_fields_with_environment_context(std::vector & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) = 0; + virtual void get_fields_req(GetFieldsResponse& _return, const GetFieldsRequest& req) = 0; + virtual void get_schema(std::vector & _return, const std::string& db_name, const std::string& table_name) = 0; + virtual void get_schema_with_environment_context(std::vector & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) = 0; + virtual void get_schema_req(GetSchemaResponse& _return, const GetSchemaRequest& req) = 0; + virtual void create_table(const Table& tbl) = 0; + virtual void create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context) = 0; + virtual void create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys, const std::vector & uniqueConstraints, const std::vector & notNullConstraints, const std::vector & defaultConstraints, const std::vector & checkConstraints) = 0; + virtual void create_table_req(const CreateTableRequest& request) = 0; + virtual void drop_constraint(const DropConstraintRequest& req) = 0; + virtual void add_primary_key(const AddPrimaryKeyRequest& req) = 0; + virtual void add_foreign_key(const AddForeignKeyRequest& req) = 0; + virtual void add_unique_constraint(const AddUniqueConstraintRequest& req) = 0; + virtual void add_not_null_constraint(const AddNotNullConstraintRequest& req) = 0; + virtual void add_default_constraint(const AddDefaultConstraintRequest& req) = 0; + virtual void add_check_constraint(const AddCheckConstraintRequest& req) = 0; + virtual void translate_table_dryrun(Table& _return, const CreateTableRequest& request) = 0; + virtual void drop_table(const std::string& dbname, const std::string& name, const bool deleteData) = 0; + virtual void drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context) = 0; + virtual void drop_table_req(const DropTableRequest& dropTableReq) = 0; + virtual void truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames) = 0; + virtual void truncate_table_req(TruncateTableResponse& _return, const TruncateTableRequest& req) = 0; + virtual void get_tables(std::vector & _return, const std::string& db_name, const std::string& pattern) = 0; + virtual void get_tables_by_type(std::vector & _return, const std::string& db_name, const std::string& pattern, const std::string& tableType) = 0; + virtual void get_all_materialized_view_objects_for_rewriting(std::vector
& _return) = 0; + virtual void get_materialized_views_for_rewriting(std::vector & _return, const std::string& db_name) = 0; + virtual void get_table_meta(std::vector & _return, const std::string& db_patterns, const std::string& tbl_patterns, const std::vector & tbl_types) = 0; + virtual void get_all_tables(std::vector & _return, const std::string& db_name) = 0; + virtual void get_tables_ext(std::vector & _return, const GetTablesExtRequest& req) = 0; + virtual void get_table_req(GetTableResult& _return, const GetTableRequest& req) = 0; + virtual void get_table_objects_by_name_req(GetTablesResult& _return, const GetTablesRequest& req) = 0; + virtual void get_materialization_invalidation_info(Materialization& _return, const CreationMetadata& creation_metadata, const std::string& validTxnList) = 0; + virtual void update_creation_metadata(const std::string& catName, const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata) = 0; + virtual void get_table_names_by_filter(std::vector & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables) = 0; + virtual void alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl) = 0; + virtual void alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context) = 0; + virtual void alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade) = 0; + virtual void alter_table_req(AlterTableResponse& _return, const AlterTableRequest& req) = 0; + virtual void add_partition(Partition& _return, const Partition& new_part) = 0; + virtual void add_partition_with_environment_context(Partition& _return, const Partition& new_part, const EnvironmentContext& environment_context) = 0; + virtual int32_t add_partitions(const std::vector & new_parts) = 0; + virtual int32_t add_partitions_pspec(const std::vector & new_parts) = 0; + virtual void append_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals) = 0; + virtual void add_partitions_req(AddPartitionsResult& _return, const AddPartitionsRequest& request) = 0; + virtual void append_partition_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const EnvironmentContext& environment_context) = 0; + virtual void append_partition_req(Partition& _return, const AppendPartitionsRequest& appendPartitionsReq) = 0; + virtual void append_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name) = 0; + virtual void append_partition_by_name_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context) = 0; + virtual bool drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData) = 0; + virtual bool drop_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData, const EnvironmentContext& environment_context) = 0; + virtual bool drop_partition_req(const DropPartitionRequest& dropPartitionReq) = 0; + virtual bool drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData) = 0; + virtual bool drop_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData, const EnvironmentContext& environment_context) = 0; + virtual void drop_partitions_req(DropPartitionsResult& _return, const DropPartitionsRequest& req) = 0; + virtual void get_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals) = 0; + virtual void get_partition_req(GetPartitionResponse& _return, const GetPartitionRequest& req) = 0; + virtual void exchange_partition(Partition& _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) = 0; + virtual void exchange_partitions(std::vector & _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) = 0; + virtual void get_partition_with_auth(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const std::string& user_name, const std::vector & group_names) = 0; + virtual void get_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name) = 0; + virtual void get_partitions(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts) = 0; + virtual void get_partitions_req(PartitionsResponse& _return, const PartitionsRequest& req) = 0; + virtual void get_partitions_with_auth(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts, const std::string& user_name, const std::vector & group_names) = 0; + virtual void get_partitions_pspec(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int32_t max_parts) = 0; + virtual void get_partition_names(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts) = 0; + virtual void fetch_partition_names_req(std::vector & _return, const PartitionsRequest& partitionReq) = 0; + virtual void get_partition_values(PartitionValuesResponse& _return, const PartitionValuesRequest& request) = 0; + virtual void get_partitions_ps(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts) = 0; + virtual void get_partitions_ps_with_auth(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts, const std::string& user_name, const std::vector & group_names) = 0; + virtual void get_partitions_ps_with_auth_req(GetPartitionsPsWithAuthResponse& _return, const GetPartitionsPsWithAuthRequest& req) = 0; + virtual void get_partition_names_ps(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts) = 0; + virtual void get_partition_names_ps_req(GetPartitionNamesPsResponse& _return, const GetPartitionNamesPsRequest& req) = 0; + virtual void get_partition_names_req(std::vector & _return, const PartitionsByExprRequest& req) = 0; + virtual void get_partitions_by_filter(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int16_t max_parts) = 0; + virtual void get_partitions_by_filter_req(std::vector & _return, const GetPartitionsByFilterRequest& req) = 0; + virtual void get_part_specs_by_filter(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int32_t max_parts) = 0; + virtual void get_partitions_by_expr(PartitionsByExprResult& _return, const PartitionsByExprRequest& req) = 0; + virtual void get_partitions_spec_by_expr(PartitionsSpecByExprResult& _return, const PartitionsByExprRequest& req) = 0; + virtual int32_t get_num_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter) = 0; + virtual void get_partitions_by_names(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & names) = 0; + virtual void get_partitions_by_names_req(GetPartitionsByNamesResult& _return, const GetPartitionsByNamesRequest& req) = 0; + virtual void get_properties(PropertyGetResponse& _return, const PropertyGetRequest& req) = 0; + virtual bool set_properties(const PropertySetRequest& req) = 0; + virtual void alter_partition(const std::string& db_name, const std::string& tbl_name, const Partition& new_part) = 0; + virtual void alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts) = 0; + virtual void alter_partitions_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts, const EnvironmentContext& environment_context) = 0; + virtual void alter_partitions_req(AlterPartitionsResponse& _return, const AlterPartitionsRequest& req) = 0; + virtual void alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context) = 0; + virtual void rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const Partition& new_part) = 0; + virtual void rename_partition_req(RenamePartitionResponse& _return, const RenamePartitionRequest& req) = 0; + virtual bool partition_name_has_valid_characters(const std::vector & part_vals, const bool throw_exception) = 0; + virtual void get_config_value(std::string& _return, const std::string& name, const std::string& defaultValue) = 0; + virtual void partition_name_to_vals(std::vector & _return, const std::string& part_name) = 0; + virtual void partition_name_to_spec(std::map & _return, const std::string& part_name) = 0; + virtual void markPartitionForEvent(const std::string& db_name, const std::string& tbl_name, const std::map & part_vals, const PartitionEventType::type eventType) = 0; + virtual bool isPartitionMarkedForEvent(const std::string& db_name, const std::string& tbl_name, const std::map & part_vals, const PartitionEventType::type eventType) = 0; + virtual void get_primary_keys(PrimaryKeysResponse& _return, const PrimaryKeysRequest& request) = 0; + virtual void get_foreign_keys(ForeignKeysResponse& _return, const ForeignKeysRequest& request) = 0; + virtual void get_unique_constraints(UniqueConstraintsResponse& _return, const UniqueConstraintsRequest& request) = 0; + virtual void get_not_null_constraints(NotNullConstraintsResponse& _return, const NotNullConstraintsRequest& request) = 0; + virtual void get_default_constraints(DefaultConstraintsResponse& _return, const DefaultConstraintsRequest& request) = 0; + virtual void get_check_constraints(CheckConstraintsResponse& _return, const CheckConstraintsRequest& request) = 0; + virtual void get_all_table_constraints(AllTableConstraintsResponse& _return, const AllTableConstraintsRequest& request) = 0; + virtual bool update_table_column_statistics(const ColumnStatistics& stats_obj) = 0; + virtual bool update_partition_column_statistics(const ColumnStatistics& stats_obj) = 0; + virtual void update_table_column_statistics_req(SetPartitionsStatsResponse& _return, const SetPartitionsStatsRequest& req) = 0; + virtual void update_partition_column_statistics_req(SetPartitionsStatsResponse& _return, const SetPartitionsStatsRequest& req) = 0; + virtual void update_transaction_statistics(const UpdateTransactionalStatsRequest& req) = 0; + virtual void get_table_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& col_name) = 0; + virtual void get_partition_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name) = 0; + virtual void get_table_statistics_req(TableStatsResult& _return, const TableStatsRequest& request) = 0; + virtual void get_partitions_statistics_req(PartitionsStatsResult& _return, const PartitionsStatsRequest& request) = 0; + virtual void get_aggr_stats_for(AggrStats& _return, const PartitionsStatsRequest& request) = 0; + virtual bool set_aggr_stats_for(const SetPartitionsStatsRequest& request) = 0; + virtual bool delete_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name, const std::string& engine) = 0; + virtual bool delete_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name, const std::string& engine) = 0; + virtual void create_function(const Function& func) = 0; + virtual void drop_function(const std::string& dbName, const std::string& funcName) = 0; + virtual void alter_function(const std::string& dbName, const std::string& funcName, const Function& newFunc) = 0; + virtual void get_functions(std::vector & _return, const std::string& dbName, const std::string& pattern) = 0; + virtual void get_function(Function& _return, const std::string& dbName, const std::string& funcName) = 0; + virtual void get_all_functions(GetAllFunctionsResponse& _return) = 0; + virtual bool create_role(const Role& role) = 0; + virtual bool drop_role(const std::string& role_name) = 0; + virtual void get_role_names(std::vector & _return) = 0; + virtual bool grant_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type, const std::string& grantor, const PrincipalType::type grantorType, const bool grant_option) = 0; + virtual bool revoke_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type) = 0; + virtual void list_roles(std::vector & _return, const std::string& principal_name, const PrincipalType::type principal_type) = 0; + virtual void grant_revoke_role(GrantRevokeRoleResponse& _return, const GrantRevokeRoleRequest& request) = 0; + virtual void get_principals_in_role(GetPrincipalsInRoleResponse& _return, const GetPrincipalsInRoleRequest& request) = 0; + virtual void get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& _return, const GetRoleGrantsForPrincipalRequest& request) = 0; + virtual void get_privilege_set(PrincipalPrivilegeSet& _return, const HiveObjectRef& hiveObject, const std::string& user_name, const std::vector & group_names) = 0; + virtual void list_privileges(std::vector & _return, const std::string& principal_name, const PrincipalType::type principal_type, const HiveObjectRef& hiveObject) = 0; + virtual bool grant_privileges(const PrivilegeBag& privileges) = 0; + virtual bool revoke_privileges(const PrivilegeBag& privileges) = 0; + virtual void grant_revoke_privileges(GrantRevokePrivilegeResponse& _return, const GrantRevokePrivilegeRequest& request) = 0; + virtual void refresh_privileges(GrantRevokePrivilegeResponse& _return, const HiveObjectRef& objToRefresh, const std::string& authorizer, const GrantRevokePrivilegeRequest& grantRequest) = 0; + virtual void set_ugi(std::vector & _return, const std::string& user_name, const std::vector & group_names) = 0; + virtual void get_delegation_token(std::string& _return, const std::string& token_owner, const std::string& renewer_kerberos_principal_name) = 0; + virtual int64_t renew_delegation_token(const std::string& token_str_form) = 0; + virtual void cancel_delegation_token(const std::string& token_str_form) = 0; + virtual bool add_token(const std::string& token_identifier, const std::string& delegation_token) = 0; + virtual bool remove_token(const std::string& token_identifier) = 0; + virtual void get_token(std::string& _return, const std::string& token_identifier) = 0; + virtual void get_all_token_identifiers(std::vector & _return) = 0; + virtual int32_t add_master_key(const std::string& key) = 0; + virtual void update_master_key(const int32_t seq_number, const std::string& key) = 0; + virtual bool remove_master_key(const int32_t key_seq) = 0; + virtual void get_master_keys(std::vector & _return) = 0; + virtual void get_open_txns(GetOpenTxnsResponse& _return) = 0; + virtual void get_open_txns_info(GetOpenTxnsInfoResponse& _return) = 0; + virtual void open_txns(OpenTxnsResponse& _return, const OpenTxnRequest& rqst) = 0; + virtual void abort_txn(const AbortTxnRequest& rqst) = 0; + virtual void abort_txns(const AbortTxnsRequest& rqst) = 0; + virtual void commit_txn(const CommitTxnRequest& rqst) = 0; + virtual int64_t get_latest_txnid_in_conflict(const int64_t txnId) = 0; + virtual void repl_tbl_writeid_state(const ReplTblWriteIdStateRequest& rqst) = 0; + virtual void get_valid_write_ids(GetValidWriteIdsResponse& _return, const GetValidWriteIdsRequest& rqst) = 0; + virtual void add_write_ids_to_min_history(const int64_t txnId, const std::map & writeIds) = 0; + virtual void allocate_table_write_ids(AllocateTableWriteIdsResponse& _return, const AllocateTableWriteIdsRequest& rqst) = 0; + virtual void get_max_allocated_table_write_id(MaxAllocatedTableWriteIdResponse& _return, const MaxAllocatedTableWriteIdRequest& rqst) = 0; + virtual void seed_write_id(const SeedTableWriteIdsRequest& rqst) = 0; + virtual void seed_txn_id(const SeedTxnIdRequest& rqst) = 0; + virtual void lock(LockResponse& _return, const LockRequest& rqst) = 0; + virtual void check_lock(LockResponse& _return, const CheckLockRequest& rqst) = 0; + virtual void unlock(const UnlockRequest& rqst) = 0; + virtual void show_locks(ShowLocksResponse& _return, const ShowLocksRequest& rqst) = 0; + virtual void heartbeat(const HeartbeatRequest& ids) = 0; + virtual void heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const HeartbeatTxnRangeRequest& txns) = 0; + virtual void compact(const CompactionRequest& rqst) = 0; + virtual void compact2(CompactionResponse& _return, const CompactionRequest& rqst) = 0; + virtual void show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst) = 0; + virtual bool submit_for_cleanup(const CompactionRequest& o1, const int64_t o2, const int64_t o3) = 0; + virtual void add_dynamic_partitions(const AddDynamicPartitions& rqst) = 0; + virtual void find_next_compact(OptionalCompactionInfoStruct& _return, const std::string& workerId) = 0; + virtual void find_next_compact2(OptionalCompactionInfoStruct& _return, const FindNextCompactRequest& rqst) = 0; + virtual void update_compactor_state(const CompactionInfoStruct& cr, const int64_t txn_id) = 0; + virtual void find_columns_with_stats(std::vector & _return, const CompactionInfoStruct& cr) = 0; + virtual void mark_cleaned(const CompactionInfoStruct& cr) = 0; + virtual void mark_compacted(const CompactionInfoStruct& cr) = 0; + virtual void mark_failed(const CompactionInfoStruct& cr) = 0; + virtual void mark_refused(const CompactionInfoStruct& cr) = 0; + virtual bool update_compaction_metrics_data(const CompactionMetricsDataStruct& data) = 0; + virtual void remove_compaction_metrics_data(const CompactionMetricsDataRequest& request) = 0; + virtual void set_hadoop_jobid(const std::string& jobId, const int64_t cq_id) = 0; + virtual void get_latest_committed_compaction_info(GetLatestCommittedCompactionInfoResponse& _return, const GetLatestCommittedCompactionInfoRequest& rqst) = 0; + virtual void get_next_notification(NotificationEventResponse& _return, const NotificationEventRequest& rqst) = 0; + virtual void get_current_notificationEventId(CurrentNotificationEventId& _return) = 0; + virtual void get_notification_events_count(NotificationEventsCountResponse& _return, const NotificationEventsCountRequest& rqst) = 0; + virtual void fire_listener_event(FireEventResponse& _return, const FireEventRequest& rqst) = 0; + virtual void flushCache() = 0; + virtual void add_write_notification_log(WriteNotificationLogResponse& _return, const WriteNotificationLogRequest& rqst) = 0; + virtual void add_write_notification_log_in_batch(WriteNotificationLogBatchResponse& _return, const WriteNotificationLogBatchRequest& rqst) = 0; + virtual void cm_recycle(CmRecycleResponse& _return, const CmRecycleRequest& request) = 0; + virtual void get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req) = 0; + virtual void get_file_metadata(GetFileMetadataResult& _return, const GetFileMetadataRequest& req) = 0; + virtual void put_file_metadata(PutFileMetadataResult& _return, const PutFileMetadataRequest& req) = 0; + virtual void clear_file_metadata(ClearFileMetadataResult& _return, const ClearFileMetadataRequest& req) = 0; + virtual void cache_file_metadata(CacheFileMetadataResult& _return, const CacheFileMetadataRequest& req) = 0; + virtual void get_metastore_db_uuid(std::string& _return) = 0; + virtual void create_resource_plan(WMCreateResourcePlanResponse& _return, const WMCreateResourcePlanRequest& request) = 0; + virtual void get_resource_plan(WMGetResourcePlanResponse& _return, const WMGetResourcePlanRequest& request) = 0; + virtual void get_active_resource_plan(WMGetActiveResourcePlanResponse& _return, const WMGetActiveResourcePlanRequest& request) = 0; + virtual void get_all_resource_plans(WMGetAllResourcePlanResponse& _return, const WMGetAllResourcePlanRequest& request) = 0; + virtual void alter_resource_plan(WMAlterResourcePlanResponse& _return, const WMAlterResourcePlanRequest& request) = 0; + virtual void validate_resource_plan(WMValidateResourcePlanResponse& _return, const WMValidateResourcePlanRequest& request) = 0; + virtual void drop_resource_plan(WMDropResourcePlanResponse& _return, const WMDropResourcePlanRequest& request) = 0; + virtual void create_wm_trigger(WMCreateTriggerResponse& _return, const WMCreateTriggerRequest& request) = 0; + virtual void alter_wm_trigger(WMAlterTriggerResponse& _return, const WMAlterTriggerRequest& request) = 0; + virtual void drop_wm_trigger(WMDropTriggerResponse& _return, const WMDropTriggerRequest& request) = 0; + virtual void get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const WMGetTriggersForResourePlanRequest& request) = 0; + virtual void create_wm_pool(WMCreatePoolResponse& _return, const WMCreatePoolRequest& request) = 0; + virtual void alter_wm_pool(WMAlterPoolResponse& _return, const WMAlterPoolRequest& request) = 0; + virtual void drop_wm_pool(WMDropPoolResponse& _return, const WMDropPoolRequest& request) = 0; + virtual void create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const WMCreateOrUpdateMappingRequest& request) = 0; + virtual void drop_wm_mapping(WMDropMappingResponse& _return, const WMDropMappingRequest& request) = 0; + virtual void create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return, const WMCreateOrDropTriggerToPoolMappingRequest& request) = 0; + virtual void create_ischema(const ISchema& schema) = 0; + virtual void alter_ischema(const AlterISchemaRequest& rqst) = 0; + virtual void get_ischema(ISchema& _return, const ISchemaName& name) = 0; + virtual void drop_ischema(const ISchemaName& name) = 0; + virtual void add_schema_version(const SchemaVersion& schemaVersion) = 0; + virtual void get_schema_version(SchemaVersion& _return, const SchemaVersionDescriptor& schemaVersion) = 0; + virtual void get_schema_latest_version(SchemaVersion& _return, const ISchemaName& schemaName) = 0; + virtual void get_schema_all_versions(std::vector & _return, const ISchemaName& schemaName) = 0; + virtual void drop_schema_version(const SchemaVersionDescriptor& schemaVersion) = 0; + virtual void get_schemas_by_cols(FindSchemasByColsResp& _return, const FindSchemasByColsRqst& rqst) = 0; + virtual void map_schema_version_to_serde(const MapSchemaVersionToSerdeRequest& rqst) = 0; + virtual void set_schema_version_state(const SetSchemaVersionStateRequest& rqst) = 0; + virtual void add_serde(const SerDeInfo& serde) = 0; + virtual void get_serde(SerDeInfo& _return, const GetSerdeRequest& rqst) = 0; + virtual void get_lock_materialization_rebuild(LockResponse& _return, const std::string& dbName, const std::string& tableName, const int64_t txnId) = 0; + virtual bool heartbeat_lock_materialization_rebuild(const std::string& dbName, const std::string& tableName, const int64_t txnId) = 0; + virtual void add_runtime_stats(const RuntimeStat& stat) = 0; + virtual void get_runtime_stats(std::vector & _return, const GetRuntimeStatsRequest& rqst) = 0; + virtual void get_partitions_with_specs(GetPartitionsResponse& _return, const GetPartitionsRequest& request) = 0; + virtual void scheduled_query_poll(ScheduledQueryPollResponse& _return, const ScheduledQueryPollRequest& request) = 0; + virtual void scheduled_query_maintenance(const ScheduledQueryMaintenanceRequest& request) = 0; + virtual void scheduled_query_progress(const ScheduledQueryProgressInfo& info) = 0; + virtual void get_scheduled_query(ScheduledQuery& _return, const ScheduledQueryKey& scheduleKey) = 0; + virtual void add_replication_metrics(const ReplicationMetricList& replicationMetricList) = 0; + virtual void get_replication_metrics(ReplicationMetricList& _return, const GetReplicationMetricsRequest& rqst) = 0; + virtual void get_open_txns_req(GetOpenTxnsResponse& _return, const GetOpenTxnsRequest& getOpenTxnsRequest) = 0; + virtual void create_stored_procedure(const StoredProcedure& proc) = 0; + virtual void get_stored_procedure(StoredProcedure& _return, const StoredProcedureRequest& request) = 0; + virtual void drop_stored_procedure(const StoredProcedureRequest& request) = 0; + virtual void get_all_stored_procedures(std::vector & _return, const ListStoredProcedureRequest& request) = 0; + virtual void find_package(Package& _return, const GetPackageRequest& request) = 0; + virtual void add_package(const AddPackageRequest& request) = 0; + virtual void get_all_packages(std::vector & _return, const ListPackageRequest& request) = 0; + virtual void drop_package(const DropPackageRequest& request) = 0; + virtual void get_all_write_event_info(std::vector & _return, const GetAllWriteEventInfoRequest& request) = 0; +}; + +class ThriftHiveMetastoreIfFactory : virtual public ::facebook::fb303::FacebookServiceIfFactory { + public: + typedef ThriftHiveMetastoreIf Handler; + + virtual ~ThriftHiveMetastoreIfFactory() {} + + virtual ThriftHiveMetastoreIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) override = 0; + virtual void releaseHandler( ::facebook::fb303::FacebookServiceIf* /* handler */) override = 0; + }; + +class ThriftHiveMetastoreIfSingletonFactory : virtual public ThriftHiveMetastoreIfFactory { + public: + ThriftHiveMetastoreIfSingletonFactory(const ::std::shared_ptr& iface) : iface_(iface) {} + virtual ~ThriftHiveMetastoreIfSingletonFactory() {} + + virtual ThriftHiveMetastoreIf* getHandler(const ::apache::thrift::TConnectionInfo&) override { + return iface_.get(); + } + virtual void releaseHandler( ::facebook::fb303::FacebookServiceIf* /* handler */) override {} + + protected: + ::std::shared_ptr iface_; +}; + +class ThriftHiveMetastoreNull : virtual public ThriftHiveMetastoreIf , virtual public ::facebook::fb303::FacebookServiceNull { + public: + virtual ~ThriftHiveMetastoreNull() {} + void abort_Compactions(AbortCompactResponse& /* _return */, const AbortCompactionRequest& /* rqst */) override { + return; + } + void getMetaConf(std::string& /* _return */, const std::string& /* key */) override { + return; + } + void setMetaConf(const std::string& /* key */, const std::string& /* value */) override { + return; + } + void create_catalog(const CreateCatalogRequest& /* catalog */) override { + return; + } + void alter_catalog(const AlterCatalogRequest& /* rqst */) override { + return; + } + void get_catalog(GetCatalogResponse& /* _return */, const GetCatalogRequest& /* catName */) override { + return; + } + void get_catalogs(GetCatalogsResponse& /* _return */) override { + return; + } + void drop_catalog(const DropCatalogRequest& /* catName */) override { + return; + } + void create_database(const Database& /* database */) override { + return; + } + void create_database_req(const CreateDatabaseRequest& /* createDatabaseRequest */) override { + return; + } + void get_database(Database& /* _return */, const std::string& /* name */) override { + return; + } + void get_database_req(Database& /* _return */, const GetDatabaseRequest& /* request */) override { + return; + } + void drop_database(const std::string& /* name */, const bool /* deleteData */, const bool /* cascade */) override { + return; + } + void drop_database_req(const DropDatabaseRequest& /* req */) override { + return; + } + void get_databases(std::vector & /* _return */, const std::string& /* pattern */) override { + return; + } + void get_all_databases(std::vector & /* _return */) override { + return; + } + void alter_database(const std::string& /* dbname */, const Database& /* db */) override { + return; + } + void alter_database_req(const AlterDatabaseRequest& /* alterDbReq */) override { + return; + } + void create_dataconnector_req(const CreateDataConnectorRequest& /* connectorReq */) override { + return; + } + void get_dataconnector_req(DataConnector& /* _return */, const GetDataConnectorRequest& /* request */) override { + return; + } + void drop_dataconnector_req(const DropDataConnectorRequest& /* dropDcReq */) override { + return; + } + void get_dataconnectors(std::vector & /* _return */) override { + return; + } + void alter_dataconnector_req(const AlterDataConnectorRequest& /* alterReq */) override { + return; + } + void get_type(Type& /* _return */, const std::string& /* name */) override { + return; + } + bool create_type(const Type& /* type */) override { + bool _return = false; + return _return; + } + bool drop_type(const std::string& /* type */) override { + bool _return = false; + return _return; + } + void get_type_all(std::map & /* _return */, const std::string& /* name */) override { + return; + } + void get_fields(std::vector & /* _return */, const std::string& /* db_name */, const std::string& /* table_name */) override { + return; + } + void get_fields_with_environment_context(std::vector & /* _return */, const std::string& /* db_name */, const std::string& /* table_name */, const EnvironmentContext& /* environment_context */) override { + return; + } + void get_fields_req(GetFieldsResponse& /* _return */, const GetFieldsRequest& /* req */) override { + return; + } + void get_schema(std::vector & /* _return */, const std::string& /* db_name */, const std::string& /* table_name */) override { + return; + } + void get_schema_with_environment_context(std::vector & /* _return */, const std::string& /* db_name */, const std::string& /* table_name */, const EnvironmentContext& /* environment_context */) override { + return; + } + void get_schema_req(GetSchemaResponse& /* _return */, const GetSchemaRequest& /* req */) override { + return; + } + void create_table(const Table& /* tbl */) override { + return; + } + void create_table_with_environment_context(const Table& /* tbl */, const EnvironmentContext& /* environment_context */) override { + return; + } + void create_table_with_constraints(const Table& /* tbl */, const std::vector & /* primaryKeys */, const std::vector & /* foreignKeys */, const std::vector & /* uniqueConstraints */, const std::vector & /* notNullConstraints */, const std::vector & /* defaultConstraints */, const std::vector & /* checkConstraints */) override { + return; + } + void create_table_req(const CreateTableRequest& /* request */) override { + return; + } + void drop_constraint(const DropConstraintRequest& /* req */) override { + return; + } + void add_primary_key(const AddPrimaryKeyRequest& /* req */) override { + return; + } + void add_foreign_key(const AddForeignKeyRequest& /* req */) override { + return; + } + void add_unique_constraint(const AddUniqueConstraintRequest& /* req */) override { + return; + } + void add_not_null_constraint(const AddNotNullConstraintRequest& /* req */) override { + return; + } + void add_default_constraint(const AddDefaultConstraintRequest& /* req */) override { + return; + } + void add_check_constraint(const AddCheckConstraintRequest& /* req */) override { + return; + } + void translate_table_dryrun(Table& /* _return */, const CreateTableRequest& /* request */) override { + return; + } + void drop_table(const std::string& /* dbname */, const std::string& /* name */, const bool /* deleteData */) override { + return; + } + void drop_table_with_environment_context(const std::string& /* dbname */, const std::string& /* name */, const bool /* deleteData */, const EnvironmentContext& /* environment_context */) override { + return; + } + void drop_table_req(const DropTableRequest& /* dropTableReq */) override { + return; + } + void truncate_table(const std::string& /* dbName */, const std::string& /* tableName */, const std::vector & /* partNames */) override { + return; + } + void truncate_table_req(TruncateTableResponse& /* _return */, const TruncateTableRequest& /* req */) override { + return; + } + void get_tables(std::vector & /* _return */, const std::string& /* db_name */, const std::string& /* pattern */) override { + return; + } + void get_tables_by_type(std::vector & /* _return */, const std::string& /* db_name */, const std::string& /* pattern */, const std::string& /* tableType */) override { + return; + } + void get_all_materialized_view_objects_for_rewriting(std::vector
& /* _return */) override { + return; + } + void get_materialized_views_for_rewriting(std::vector & /* _return */, const std::string& /* db_name */) override { + return; + } + void get_table_meta(std::vector & /* _return */, const std::string& /* db_patterns */, const std::string& /* tbl_patterns */, const std::vector & /* tbl_types */) override { + return; + } + void get_all_tables(std::vector & /* _return */, const std::string& /* db_name */) override { + return; + } + void get_tables_ext(std::vector & /* _return */, const GetTablesExtRequest& /* req */) override { + return; + } + void get_table_req(GetTableResult& /* _return */, const GetTableRequest& /* req */) override { + return; + } + void get_table_objects_by_name_req(GetTablesResult& /* _return */, const GetTablesRequest& /* req */) override { + return; + } + void get_materialization_invalidation_info(Materialization& /* _return */, const CreationMetadata& /* creation_metadata */, const std::string& /* validTxnList */) override { + return; + } + void update_creation_metadata(const std::string& /* catName */, const std::string& /* dbname */, const std::string& /* tbl_name */, const CreationMetadata& /* creation_metadata */) override { + return; + } + void get_table_names_by_filter(std::vector & /* _return */, const std::string& /* dbname */, const std::string& /* filter */, const int16_t /* max_tables */) override { + return; + } + void alter_table(const std::string& /* dbname */, const std::string& /* tbl_name */, const Table& /* new_tbl */) override { + return; + } + void alter_table_with_environment_context(const std::string& /* dbname */, const std::string& /* tbl_name */, const Table& /* new_tbl */, const EnvironmentContext& /* environment_context */) override { + return; + } + void alter_table_with_cascade(const std::string& /* dbname */, const std::string& /* tbl_name */, const Table& /* new_tbl */, const bool /* cascade */) override { + return; + } + void alter_table_req(AlterTableResponse& /* _return */, const AlterTableRequest& /* req */) override { + return; + } + void add_partition(Partition& /* _return */, const Partition& /* new_part */) override { + return; + } + void add_partition_with_environment_context(Partition& /* _return */, const Partition& /* new_part */, const EnvironmentContext& /* environment_context */) override { + return; + } + int32_t add_partitions(const std::vector & /* new_parts */) override { + int32_t _return = 0; + return _return; + } + int32_t add_partitions_pspec(const std::vector & /* new_parts */) override { + int32_t _return = 0; + return _return; + } + void append_partition(Partition& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector & /* part_vals */) override { + return; + } + void add_partitions_req(AddPartitionsResult& /* _return */, const AddPartitionsRequest& /* request */) override { + return; + } + void append_partition_with_environment_context(Partition& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector & /* part_vals */, const EnvironmentContext& /* environment_context */) override { + return; + } + void append_partition_req(Partition& /* _return */, const AppendPartitionsRequest& /* appendPartitionsReq */) override { + return; + } + void append_partition_by_name(Partition& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* part_name */) override { + return; + } + void append_partition_by_name_with_environment_context(Partition& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* part_name */, const EnvironmentContext& /* environment_context */) override { + return; + } + bool drop_partition(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector & /* part_vals */, const bool /* deleteData */) override { + bool _return = false; + return _return; + } + bool drop_partition_with_environment_context(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector & /* part_vals */, const bool /* deleteData */, const EnvironmentContext& /* environment_context */) override { + bool _return = false; + return _return; + } + bool drop_partition_req(const DropPartitionRequest& /* dropPartitionReq */) override { + bool _return = false; + return _return; + } + bool drop_partition_by_name(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* part_name */, const bool /* deleteData */) override { + bool _return = false; + return _return; + } + bool drop_partition_by_name_with_environment_context(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* part_name */, const bool /* deleteData */, const EnvironmentContext& /* environment_context */) override { + bool _return = false; + return _return; + } + void drop_partitions_req(DropPartitionsResult& /* _return */, const DropPartitionsRequest& /* req */) override { + return; + } + void get_partition(Partition& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector & /* part_vals */) override { + return; + } + void get_partition_req(GetPartitionResponse& /* _return */, const GetPartitionRequest& /* req */) override { + return; + } + void exchange_partition(Partition& /* _return */, const std::map & /* partitionSpecs */, const std::string& /* source_db */, const std::string& /* source_table_name */, const std::string& /* dest_db */, const std::string& /* dest_table_name */) override { + return; + } + void exchange_partitions(std::vector & /* _return */, const std::map & /* partitionSpecs */, const std::string& /* source_db */, const std::string& /* source_table_name */, const std::string& /* dest_db */, const std::string& /* dest_table_name */) override { + return; + } + void get_partition_with_auth(Partition& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector & /* part_vals */, const std::string& /* user_name */, const std::vector & /* group_names */) override { + return; + } + void get_partition_by_name(Partition& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* part_name */) override { + return; + } + void get_partitions(std::vector & /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const int16_t /* max_parts */) override { + return; + } + void get_partitions_req(PartitionsResponse& /* _return */, const PartitionsRequest& /* req */) override { + return; + } + void get_partitions_with_auth(std::vector & /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const int16_t /* max_parts */, const std::string& /* user_name */, const std::vector & /* group_names */) override { + return; + } + void get_partitions_pspec(std::vector & /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const int32_t /* max_parts */) override { + return; + } + void get_partition_names(std::vector & /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const int16_t /* max_parts */) override { + return; + } + void fetch_partition_names_req(std::vector & /* _return */, const PartitionsRequest& /* partitionReq */) override { + return; + } + void get_partition_values(PartitionValuesResponse& /* _return */, const PartitionValuesRequest& /* request */) override { + return; + } + void get_partitions_ps(std::vector & /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector & /* part_vals */, const int16_t /* max_parts */) override { + return; + } + void get_partitions_ps_with_auth(std::vector & /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector & /* part_vals */, const int16_t /* max_parts */, const std::string& /* user_name */, const std::vector & /* group_names */) override { + return; + } + void get_partitions_ps_with_auth_req(GetPartitionsPsWithAuthResponse& /* _return */, const GetPartitionsPsWithAuthRequest& /* req */) override { + return; + } + void get_partition_names_ps(std::vector & /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector & /* part_vals */, const int16_t /* max_parts */) override { + return; + } + void get_partition_names_ps_req(GetPartitionNamesPsResponse& /* _return */, const GetPartitionNamesPsRequest& /* req */) override { + return; + } + void get_partition_names_req(std::vector & /* _return */, const PartitionsByExprRequest& /* req */) override { + return; + } + void get_partitions_by_filter(std::vector & /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* filter */, const int16_t /* max_parts */) override { + return; + } + void get_partitions_by_filter_req(std::vector & /* _return */, const GetPartitionsByFilterRequest& /* req */) override { + return; + } + void get_part_specs_by_filter(std::vector & /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* filter */, const int32_t /* max_parts */) override { + return; + } + void get_partitions_by_expr(PartitionsByExprResult& /* _return */, const PartitionsByExprRequest& /* req */) override { + return; + } + void get_partitions_spec_by_expr(PartitionsSpecByExprResult& /* _return */, const PartitionsByExprRequest& /* req */) override { + return; + } + int32_t get_num_partitions_by_filter(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* filter */) override { + int32_t _return = 0; + return _return; + } + void get_partitions_by_names(std::vector & /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector & /* names */) override { + return; + } + void get_partitions_by_names_req(GetPartitionsByNamesResult& /* _return */, const GetPartitionsByNamesRequest& /* req */) override { + return; + } + void get_properties(PropertyGetResponse& /* _return */, const PropertyGetRequest& /* req */) override { + return; + } + bool set_properties(const PropertySetRequest& /* req */) override { + bool _return = false; + return _return; + } + void alter_partition(const std::string& /* db_name */, const std::string& /* tbl_name */, const Partition& /* new_part */) override { + return; + } + void alter_partitions(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector & /* new_parts */) override { + return; + } + void alter_partitions_with_environment_context(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector & /* new_parts */, const EnvironmentContext& /* environment_context */) override { + return; + } + void alter_partitions_req(AlterPartitionsResponse& /* _return */, const AlterPartitionsRequest& /* req */) override { + return; + } + void alter_partition_with_environment_context(const std::string& /* db_name */, const std::string& /* tbl_name */, const Partition& /* new_part */, const EnvironmentContext& /* environment_context */) override { + return; + } + void rename_partition(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector & /* part_vals */, const Partition& /* new_part */) override { + return; + } + void rename_partition_req(RenamePartitionResponse& /* _return */, const RenamePartitionRequest& /* req */) override { + return; + } + bool partition_name_has_valid_characters(const std::vector & /* part_vals */, const bool /* throw_exception */) override { + bool _return = false; + return _return; + } + void get_config_value(std::string& /* _return */, const std::string& /* name */, const std::string& /* defaultValue */) override { + return; + } + void partition_name_to_vals(std::vector & /* _return */, const std::string& /* part_name */) override { + return; + } + void partition_name_to_spec(std::map & /* _return */, const std::string& /* part_name */) override { + return; + } + void markPartitionForEvent(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::map & /* part_vals */, const PartitionEventType::type /* eventType */) override { + return; + } + bool isPartitionMarkedForEvent(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::map & /* part_vals */, const PartitionEventType::type /* eventType */) override { + bool _return = false; + return _return; + } + void get_primary_keys(PrimaryKeysResponse& /* _return */, const PrimaryKeysRequest& /* request */) override { + return; + } + void get_foreign_keys(ForeignKeysResponse& /* _return */, const ForeignKeysRequest& /* request */) override { + return; + } + void get_unique_constraints(UniqueConstraintsResponse& /* _return */, const UniqueConstraintsRequest& /* request */) override { + return; + } + void get_not_null_constraints(NotNullConstraintsResponse& /* _return */, const NotNullConstraintsRequest& /* request */) override { + return; + } + void get_default_constraints(DefaultConstraintsResponse& /* _return */, const DefaultConstraintsRequest& /* request */) override { + return; + } + void get_check_constraints(CheckConstraintsResponse& /* _return */, const CheckConstraintsRequest& /* request */) override { + return; + } + void get_all_table_constraints(AllTableConstraintsResponse& /* _return */, const AllTableConstraintsRequest& /* request */) override { + return; + } + bool update_table_column_statistics(const ColumnStatistics& /* stats_obj */) override { + bool _return = false; + return _return; + } + bool update_partition_column_statistics(const ColumnStatistics& /* stats_obj */) override { + bool _return = false; + return _return; + } + void update_table_column_statistics_req(SetPartitionsStatsResponse& /* _return */, const SetPartitionsStatsRequest& /* req */) override { + return; + } + void update_partition_column_statistics_req(SetPartitionsStatsResponse& /* _return */, const SetPartitionsStatsRequest& /* req */) override { + return; + } + void update_transaction_statistics(const UpdateTransactionalStatsRequest& /* req */) override { + return; + } + void get_table_column_statistics(ColumnStatistics& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* col_name */) override { + return; + } + void get_partition_column_statistics(ColumnStatistics& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* part_name */, const std::string& /* col_name */) override { + return; + } + void get_table_statistics_req(TableStatsResult& /* _return */, const TableStatsRequest& /* request */) override { + return; + } + void get_partitions_statistics_req(PartitionsStatsResult& /* _return */, const PartitionsStatsRequest& /* request */) override { + return; + } + void get_aggr_stats_for(AggrStats& /* _return */, const PartitionsStatsRequest& /* request */) override { + return; + } + bool set_aggr_stats_for(const SetPartitionsStatsRequest& /* request */) override { + bool _return = false; + return _return; + } + bool delete_partition_column_statistics(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* part_name */, const std::string& /* col_name */, const std::string& /* engine */) override { + bool _return = false; + return _return; + } + bool delete_table_column_statistics(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* col_name */, const std::string& /* engine */) override { + bool _return = false; + return _return; + } + void create_function(const Function& /* func */) override { + return; + } + void drop_function(const std::string& /* dbName */, const std::string& /* funcName */) override { + return; + } + void alter_function(const std::string& /* dbName */, const std::string& /* funcName */, const Function& /* newFunc */) override { + return; + } + void get_functions(std::vector & /* _return */, const std::string& /* dbName */, const std::string& /* pattern */) override { + return; + } + void get_function(Function& /* _return */, const std::string& /* dbName */, const std::string& /* funcName */) override { + return; + } + void get_all_functions(GetAllFunctionsResponse& /* _return */) override { + return; + } + bool create_role(const Role& /* role */) override { + bool _return = false; + return _return; + } + bool drop_role(const std::string& /* role_name */) override { + bool _return = false; + return _return; + } + void get_role_names(std::vector & /* _return */) override { + return; + } + bool grant_role(const std::string& /* role_name */, const std::string& /* principal_name */, const PrincipalType::type /* principal_type */, const std::string& /* grantor */, const PrincipalType::type /* grantorType */, const bool /* grant_option */) override { + bool _return = false; + return _return; + } + bool revoke_role(const std::string& /* role_name */, const std::string& /* principal_name */, const PrincipalType::type /* principal_type */) override { + bool _return = false; + return _return; + } + void list_roles(std::vector & /* _return */, const std::string& /* principal_name */, const PrincipalType::type /* principal_type */) override { + return; + } + void grant_revoke_role(GrantRevokeRoleResponse& /* _return */, const GrantRevokeRoleRequest& /* request */) override { + return; + } + void get_principals_in_role(GetPrincipalsInRoleResponse& /* _return */, const GetPrincipalsInRoleRequest& /* request */) override { + return; + } + void get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& /* _return */, const GetRoleGrantsForPrincipalRequest& /* request */) override { + return; + } + void get_privilege_set(PrincipalPrivilegeSet& /* _return */, const HiveObjectRef& /* hiveObject */, const std::string& /* user_name */, const std::vector & /* group_names */) override { + return; + } + void list_privileges(std::vector & /* _return */, const std::string& /* principal_name */, const PrincipalType::type /* principal_type */, const HiveObjectRef& /* hiveObject */) override { + return; + } + bool grant_privileges(const PrivilegeBag& /* privileges */) override { + bool _return = false; + return _return; + } + bool revoke_privileges(const PrivilegeBag& /* privileges */) override { + bool _return = false; + return _return; + } + void grant_revoke_privileges(GrantRevokePrivilegeResponse& /* _return */, const GrantRevokePrivilegeRequest& /* request */) override { + return; + } + void refresh_privileges(GrantRevokePrivilegeResponse& /* _return */, const HiveObjectRef& /* objToRefresh */, const std::string& /* authorizer */, const GrantRevokePrivilegeRequest& /* grantRequest */) override { + return; + } + void set_ugi(std::vector & /* _return */, const std::string& /* user_name */, const std::vector & /* group_names */) override { + return; + } + void get_delegation_token(std::string& /* _return */, const std::string& /* token_owner */, const std::string& /* renewer_kerberos_principal_name */) override { + return; + } + int64_t renew_delegation_token(const std::string& /* token_str_form */) override { + int64_t _return = 0; + return _return; + } + void cancel_delegation_token(const std::string& /* token_str_form */) override { + return; + } + bool add_token(const std::string& /* token_identifier */, const std::string& /* delegation_token */) override { + bool _return = false; + return _return; + } + bool remove_token(const std::string& /* token_identifier */) override { + bool _return = false; + return _return; + } + void get_token(std::string& /* _return */, const std::string& /* token_identifier */) override { + return; + } + void get_all_token_identifiers(std::vector & /* _return */) override { + return; + } + int32_t add_master_key(const std::string& /* key */) override { + int32_t _return = 0; + return _return; + } + void update_master_key(const int32_t /* seq_number */, const std::string& /* key */) override { + return; + } + bool remove_master_key(const int32_t /* key_seq */) override { + bool _return = false; + return _return; + } + void get_master_keys(std::vector & /* _return */) override { + return; + } + void get_open_txns(GetOpenTxnsResponse& /* _return */) override { + return; + } + void get_open_txns_info(GetOpenTxnsInfoResponse& /* _return */) override { + return; + } + void open_txns(OpenTxnsResponse& /* _return */, const OpenTxnRequest& /* rqst */) override { + return; + } + void abort_txn(const AbortTxnRequest& /* rqst */) override { + return; + } + void abort_txns(const AbortTxnsRequest& /* rqst */) override { + return; + } + void commit_txn(const CommitTxnRequest& /* rqst */) override { + return; + } + int64_t get_latest_txnid_in_conflict(const int64_t /* txnId */) override { + int64_t _return = 0; + return _return; + } + void repl_tbl_writeid_state(const ReplTblWriteIdStateRequest& /* rqst */) override { + return; + } + void get_valid_write_ids(GetValidWriteIdsResponse& /* _return */, const GetValidWriteIdsRequest& /* rqst */) override { + return; + } + void add_write_ids_to_min_history(const int64_t /* txnId */, const std::map & /* writeIds */) override { + return; + } + void allocate_table_write_ids(AllocateTableWriteIdsResponse& /* _return */, const AllocateTableWriteIdsRequest& /* rqst */) override { + return; + } + void get_max_allocated_table_write_id(MaxAllocatedTableWriteIdResponse& /* _return */, const MaxAllocatedTableWriteIdRequest& /* rqst */) override { + return; + } + void seed_write_id(const SeedTableWriteIdsRequest& /* rqst */) override { + return; + } + void seed_txn_id(const SeedTxnIdRequest& /* rqst */) override { + return; + } + void lock(LockResponse& /* _return */, const LockRequest& /* rqst */) override { + return; + } + void check_lock(LockResponse& /* _return */, const CheckLockRequest& /* rqst */) override { + return; + } + void unlock(const UnlockRequest& /* rqst */) override { + return; + } + void show_locks(ShowLocksResponse& /* _return */, const ShowLocksRequest& /* rqst */) override { + return; + } + void heartbeat(const HeartbeatRequest& /* ids */) override { + return; + } + void heartbeat_txn_range(HeartbeatTxnRangeResponse& /* _return */, const HeartbeatTxnRangeRequest& /* txns */) override { + return; + } + void compact(const CompactionRequest& /* rqst */) override { + return; + } + void compact2(CompactionResponse& /* _return */, const CompactionRequest& /* rqst */) override { + return; + } + void show_compact(ShowCompactResponse& /* _return */, const ShowCompactRequest& /* rqst */) override { + return; + } + bool submit_for_cleanup(const CompactionRequest& /* o1 */, const int64_t /* o2 */, const int64_t /* o3 */) override { + bool _return = false; + return _return; + } + void add_dynamic_partitions(const AddDynamicPartitions& /* rqst */) override { + return; + } + void find_next_compact(OptionalCompactionInfoStruct& /* _return */, const std::string& /* workerId */) override { + return; + } + void find_next_compact2(OptionalCompactionInfoStruct& /* _return */, const FindNextCompactRequest& /* rqst */) override { + return; + } + void update_compactor_state(const CompactionInfoStruct& /* cr */, const int64_t /* txn_id */) override { + return; + } + void find_columns_with_stats(std::vector & /* _return */, const CompactionInfoStruct& /* cr */) override { + return; + } + void mark_cleaned(const CompactionInfoStruct& /* cr */) override { + return; + } + void mark_compacted(const CompactionInfoStruct& /* cr */) override { + return; + } + void mark_failed(const CompactionInfoStruct& /* cr */) override { + return; + } + void mark_refused(const CompactionInfoStruct& /* cr */) override { + return; + } + bool update_compaction_metrics_data(const CompactionMetricsDataStruct& /* data */) override { + bool _return = false; + return _return; + } + void remove_compaction_metrics_data(const CompactionMetricsDataRequest& /* request */) override { + return; + } + void set_hadoop_jobid(const std::string& /* jobId */, const int64_t /* cq_id */) override { + return; + } + void get_latest_committed_compaction_info(GetLatestCommittedCompactionInfoResponse& /* _return */, const GetLatestCommittedCompactionInfoRequest& /* rqst */) override { + return; + } + void get_next_notification(NotificationEventResponse& /* _return */, const NotificationEventRequest& /* rqst */) override { + return; + } + void get_current_notificationEventId(CurrentNotificationEventId& /* _return */) override { + return; + } + void get_notification_events_count(NotificationEventsCountResponse& /* _return */, const NotificationEventsCountRequest& /* rqst */) override { + return; + } + void fire_listener_event(FireEventResponse& /* _return */, const FireEventRequest& /* rqst */) override { + return; + } + void flushCache() override { + return; + } + void add_write_notification_log(WriteNotificationLogResponse& /* _return */, const WriteNotificationLogRequest& /* rqst */) override { + return; + } + void add_write_notification_log_in_batch(WriteNotificationLogBatchResponse& /* _return */, const WriteNotificationLogBatchRequest& /* rqst */) override { + return; + } + void cm_recycle(CmRecycleResponse& /* _return */, const CmRecycleRequest& /* request */) override { + return; + } + void get_file_metadata_by_expr(GetFileMetadataByExprResult& /* _return */, const GetFileMetadataByExprRequest& /* req */) override { + return; + } + void get_file_metadata(GetFileMetadataResult& /* _return */, const GetFileMetadataRequest& /* req */) override { + return; + } + void put_file_metadata(PutFileMetadataResult& /* _return */, const PutFileMetadataRequest& /* req */) override { + return; + } + void clear_file_metadata(ClearFileMetadataResult& /* _return */, const ClearFileMetadataRequest& /* req */) override { + return; + } + void cache_file_metadata(CacheFileMetadataResult& /* _return */, const CacheFileMetadataRequest& /* req */) override { + return; + } + void get_metastore_db_uuid(std::string& /* _return */) override { + return; + } + void create_resource_plan(WMCreateResourcePlanResponse& /* _return */, const WMCreateResourcePlanRequest& /* request */) override { + return; + } + void get_resource_plan(WMGetResourcePlanResponse& /* _return */, const WMGetResourcePlanRequest& /* request */) override { + return; + } + void get_active_resource_plan(WMGetActiveResourcePlanResponse& /* _return */, const WMGetActiveResourcePlanRequest& /* request */) override { + return; + } + void get_all_resource_plans(WMGetAllResourcePlanResponse& /* _return */, const WMGetAllResourcePlanRequest& /* request */) override { + return; + } + void alter_resource_plan(WMAlterResourcePlanResponse& /* _return */, const WMAlterResourcePlanRequest& /* request */) override { + return; + } + void validate_resource_plan(WMValidateResourcePlanResponse& /* _return */, const WMValidateResourcePlanRequest& /* request */) override { + return; + } + void drop_resource_plan(WMDropResourcePlanResponse& /* _return */, const WMDropResourcePlanRequest& /* request */) override { + return; + } + void create_wm_trigger(WMCreateTriggerResponse& /* _return */, const WMCreateTriggerRequest& /* request */) override { + return; + } + void alter_wm_trigger(WMAlterTriggerResponse& /* _return */, const WMAlterTriggerRequest& /* request */) override { + return; + } + void drop_wm_trigger(WMDropTriggerResponse& /* _return */, const WMDropTriggerRequest& /* request */) override { + return; + } + void get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& /* _return */, const WMGetTriggersForResourePlanRequest& /* request */) override { + return; + } + void create_wm_pool(WMCreatePoolResponse& /* _return */, const WMCreatePoolRequest& /* request */) override { + return; + } + void alter_wm_pool(WMAlterPoolResponse& /* _return */, const WMAlterPoolRequest& /* request */) override { + return; + } + void drop_wm_pool(WMDropPoolResponse& /* _return */, const WMDropPoolRequest& /* request */) override { + return; + } + void create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& /* _return */, const WMCreateOrUpdateMappingRequest& /* request */) override { + return; + } + void drop_wm_mapping(WMDropMappingResponse& /* _return */, const WMDropMappingRequest& /* request */) override { + return; + } + void create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& /* _return */, const WMCreateOrDropTriggerToPoolMappingRequest& /* request */) override { + return; + } + void create_ischema(const ISchema& /* schema */) override { + return; + } + void alter_ischema(const AlterISchemaRequest& /* rqst */) override { + return; + } + void get_ischema(ISchema& /* _return */, const ISchemaName& /* name */) override { + return; + } + void drop_ischema(const ISchemaName& /* name */) override { + return; + } + void add_schema_version(const SchemaVersion& /* schemaVersion */) override { + return; + } + void get_schema_version(SchemaVersion& /* _return */, const SchemaVersionDescriptor& /* schemaVersion */) override { + return; + } + void get_schema_latest_version(SchemaVersion& /* _return */, const ISchemaName& /* schemaName */) override { + return; + } + void get_schema_all_versions(std::vector & /* _return */, const ISchemaName& /* schemaName */) override { + return; + } + void drop_schema_version(const SchemaVersionDescriptor& /* schemaVersion */) override { + return; + } + void get_schemas_by_cols(FindSchemasByColsResp& /* _return */, const FindSchemasByColsRqst& /* rqst */) override { + return; + } + void map_schema_version_to_serde(const MapSchemaVersionToSerdeRequest& /* rqst */) override { + return; + } + void set_schema_version_state(const SetSchemaVersionStateRequest& /* rqst */) override { + return; + } + void add_serde(const SerDeInfo& /* serde */) override { + return; + } + void get_serde(SerDeInfo& /* _return */, const GetSerdeRequest& /* rqst */) override { + return; + } + void get_lock_materialization_rebuild(LockResponse& /* _return */, const std::string& /* dbName */, const std::string& /* tableName */, const int64_t /* txnId */) override { + return; + } + bool heartbeat_lock_materialization_rebuild(const std::string& /* dbName */, const std::string& /* tableName */, const int64_t /* txnId */) override { + bool _return = false; + return _return; + } + void add_runtime_stats(const RuntimeStat& /* stat */) override { + return; + } + void get_runtime_stats(std::vector & /* _return */, const GetRuntimeStatsRequest& /* rqst */) override { + return; + } + void get_partitions_with_specs(GetPartitionsResponse& /* _return */, const GetPartitionsRequest& /* request */) override { + return; + } + void scheduled_query_poll(ScheduledQueryPollResponse& /* _return */, const ScheduledQueryPollRequest& /* request */) override { + return; + } + void scheduled_query_maintenance(const ScheduledQueryMaintenanceRequest& /* request */) override { + return; + } + void scheduled_query_progress(const ScheduledQueryProgressInfo& /* info */) override { + return; + } + void get_scheduled_query(ScheduledQuery& /* _return */, const ScheduledQueryKey& /* scheduleKey */) override { + return; + } + void add_replication_metrics(const ReplicationMetricList& /* replicationMetricList */) override { + return; + } + void get_replication_metrics(ReplicationMetricList& /* _return */, const GetReplicationMetricsRequest& /* rqst */) override { + return; + } + void get_open_txns_req(GetOpenTxnsResponse& /* _return */, const GetOpenTxnsRequest& /* getOpenTxnsRequest */) override { + return; + } + void create_stored_procedure(const StoredProcedure& /* proc */) override { + return; + } + void get_stored_procedure(StoredProcedure& /* _return */, const StoredProcedureRequest& /* request */) override { + return; + } + void drop_stored_procedure(const StoredProcedureRequest& /* request */) override { + return; + } + void get_all_stored_procedures(std::vector & /* _return */, const ListStoredProcedureRequest& /* request */) override { + return; + } + void find_package(Package& /* _return */, const GetPackageRequest& /* request */) override { + return; + } + void add_package(const AddPackageRequest& /* request */) override { + return; + } + void get_all_packages(std::vector & /* _return */, const ListPackageRequest& /* request */) override { + return; + } + void drop_package(const DropPackageRequest& /* request */) override { + return; + } + void get_all_write_event_info(std::vector & /* _return */, const GetAllWriteEventInfoRequest& /* request */) override { + return; + } +}; + +typedef struct _ThriftHiveMetastore_abort_Compactions_args__isset { + _ThriftHiveMetastore_abort_Compactions_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_abort_Compactions_args__isset; + +class ThriftHiveMetastore_abort_Compactions_args { + public: + + ThriftHiveMetastore_abort_Compactions_args(const ThriftHiveMetastore_abort_Compactions_args&); + ThriftHiveMetastore_abort_Compactions_args& operator=(const ThriftHiveMetastore_abort_Compactions_args&); + ThriftHiveMetastore_abort_Compactions_args() noexcept; + + virtual ~ThriftHiveMetastore_abort_Compactions_args() noexcept; + AbortCompactionRequest rqst; + + _ThriftHiveMetastore_abort_Compactions_args__isset __isset; + + void __set_rqst(const AbortCompactionRequest& val); + + bool operator == (const ThriftHiveMetastore_abort_Compactions_args & rhs) const; + bool operator != (const ThriftHiveMetastore_abort_Compactions_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_abort_Compactions_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_abort_Compactions_pargs { + public: + + + virtual ~ThriftHiveMetastore_abort_Compactions_pargs() noexcept; + const AbortCompactionRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_abort_Compactions_result__isset { + _ThriftHiveMetastore_abort_Compactions_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_abort_Compactions_result__isset; + +class ThriftHiveMetastore_abort_Compactions_result { + public: + + ThriftHiveMetastore_abort_Compactions_result(const ThriftHiveMetastore_abort_Compactions_result&); + ThriftHiveMetastore_abort_Compactions_result& operator=(const ThriftHiveMetastore_abort_Compactions_result&); + ThriftHiveMetastore_abort_Compactions_result() noexcept; + + virtual ~ThriftHiveMetastore_abort_Compactions_result() noexcept; + AbortCompactResponse success; + + _ThriftHiveMetastore_abort_Compactions_result__isset __isset; + + void __set_success(const AbortCompactResponse& val); + + bool operator == (const ThriftHiveMetastore_abort_Compactions_result & rhs) const; + bool operator != (const ThriftHiveMetastore_abort_Compactions_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_abort_Compactions_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_abort_Compactions_presult__isset { + _ThriftHiveMetastore_abort_Compactions_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_abort_Compactions_presult__isset; + +class ThriftHiveMetastore_abort_Compactions_presult { + public: + + + virtual ~ThriftHiveMetastore_abort_Compactions_presult() noexcept; + AbortCompactResponse* success; + + _ThriftHiveMetastore_abort_Compactions_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_getMetaConf_args__isset { + _ThriftHiveMetastore_getMetaConf_args__isset() : key(false) {} + bool key :1; +} _ThriftHiveMetastore_getMetaConf_args__isset; + +class ThriftHiveMetastore_getMetaConf_args { + public: + + ThriftHiveMetastore_getMetaConf_args(const ThriftHiveMetastore_getMetaConf_args&); + ThriftHiveMetastore_getMetaConf_args& operator=(const ThriftHiveMetastore_getMetaConf_args&); + ThriftHiveMetastore_getMetaConf_args() noexcept; + + virtual ~ThriftHiveMetastore_getMetaConf_args() noexcept; + std::string key; + + _ThriftHiveMetastore_getMetaConf_args__isset __isset; + + void __set_key(const std::string& val); + + bool operator == (const ThriftHiveMetastore_getMetaConf_args & rhs) const; + bool operator != (const ThriftHiveMetastore_getMetaConf_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_getMetaConf_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_getMetaConf_pargs { + public: + + + virtual ~ThriftHiveMetastore_getMetaConf_pargs() noexcept; + const std::string* key; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_getMetaConf_result__isset { + _ThriftHiveMetastore_getMetaConf_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_getMetaConf_result__isset; + +class ThriftHiveMetastore_getMetaConf_result { + public: + + ThriftHiveMetastore_getMetaConf_result(const ThriftHiveMetastore_getMetaConf_result&); + ThriftHiveMetastore_getMetaConf_result& operator=(const ThriftHiveMetastore_getMetaConf_result&); + ThriftHiveMetastore_getMetaConf_result() noexcept; + + virtual ~ThriftHiveMetastore_getMetaConf_result() noexcept; + std::string success; + MetaException o1; + + _ThriftHiveMetastore_getMetaConf_result__isset __isset; + + void __set_success(const std::string& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_getMetaConf_result & rhs) const; + bool operator != (const ThriftHiveMetastore_getMetaConf_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_getMetaConf_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_getMetaConf_presult__isset { + _ThriftHiveMetastore_getMetaConf_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_getMetaConf_presult__isset; + +class ThriftHiveMetastore_getMetaConf_presult { + public: + + + virtual ~ThriftHiveMetastore_getMetaConf_presult() noexcept; + std::string* success; + MetaException o1; + + _ThriftHiveMetastore_getMetaConf_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_setMetaConf_args__isset { + _ThriftHiveMetastore_setMetaConf_args__isset() : key(false), value(false) {} + bool key :1; + bool value :1; +} _ThriftHiveMetastore_setMetaConf_args__isset; + +class ThriftHiveMetastore_setMetaConf_args { + public: + + ThriftHiveMetastore_setMetaConf_args(const ThriftHiveMetastore_setMetaConf_args&); + ThriftHiveMetastore_setMetaConf_args& operator=(const ThriftHiveMetastore_setMetaConf_args&); + ThriftHiveMetastore_setMetaConf_args() noexcept; + + virtual ~ThriftHiveMetastore_setMetaConf_args() noexcept; + std::string key; + std::string value; + + _ThriftHiveMetastore_setMetaConf_args__isset __isset; + + void __set_key(const std::string& val); + + void __set_value(const std::string& val); + + bool operator == (const ThriftHiveMetastore_setMetaConf_args & rhs) const; + bool operator != (const ThriftHiveMetastore_setMetaConf_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_setMetaConf_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_setMetaConf_pargs { + public: + + + virtual ~ThriftHiveMetastore_setMetaConf_pargs() noexcept; + const std::string* key; + const std::string* value; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_setMetaConf_result__isset { + _ThriftHiveMetastore_setMetaConf_result__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_setMetaConf_result__isset; + +class ThriftHiveMetastore_setMetaConf_result { + public: + + ThriftHiveMetastore_setMetaConf_result(const ThriftHiveMetastore_setMetaConf_result&); + ThriftHiveMetastore_setMetaConf_result& operator=(const ThriftHiveMetastore_setMetaConf_result&); + ThriftHiveMetastore_setMetaConf_result() noexcept; + + virtual ~ThriftHiveMetastore_setMetaConf_result() noexcept; + MetaException o1; + + _ThriftHiveMetastore_setMetaConf_result__isset __isset; + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_setMetaConf_result & rhs) const; + bool operator != (const ThriftHiveMetastore_setMetaConf_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_setMetaConf_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_setMetaConf_presult__isset { + _ThriftHiveMetastore_setMetaConf_presult__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_setMetaConf_presult__isset; + +class ThriftHiveMetastore_setMetaConf_presult { + public: + + + virtual ~ThriftHiveMetastore_setMetaConf_presult() noexcept; + MetaException o1; + + _ThriftHiveMetastore_setMetaConf_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_create_catalog_args__isset { + _ThriftHiveMetastore_create_catalog_args__isset() : catalog(false) {} + bool catalog :1; +} _ThriftHiveMetastore_create_catalog_args__isset; + +class ThriftHiveMetastore_create_catalog_args { + public: + + ThriftHiveMetastore_create_catalog_args(const ThriftHiveMetastore_create_catalog_args&); + ThriftHiveMetastore_create_catalog_args& operator=(const ThriftHiveMetastore_create_catalog_args&); + ThriftHiveMetastore_create_catalog_args() noexcept; + + virtual ~ThriftHiveMetastore_create_catalog_args() noexcept; + CreateCatalogRequest catalog; + + _ThriftHiveMetastore_create_catalog_args__isset __isset; + + void __set_catalog(const CreateCatalogRequest& val); + + bool operator == (const ThriftHiveMetastore_create_catalog_args & rhs) const; + bool operator != (const ThriftHiveMetastore_create_catalog_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_catalog_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_create_catalog_pargs { + public: + + + virtual ~ThriftHiveMetastore_create_catalog_pargs() noexcept; + const CreateCatalogRequest* catalog; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_catalog_result__isset { + _ThriftHiveMetastore_create_catalog_result__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_create_catalog_result__isset; + +class ThriftHiveMetastore_create_catalog_result { + public: + + ThriftHiveMetastore_create_catalog_result(const ThriftHiveMetastore_create_catalog_result&); + ThriftHiveMetastore_create_catalog_result& operator=(const ThriftHiveMetastore_create_catalog_result&); + ThriftHiveMetastore_create_catalog_result() noexcept; + + virtual ~ThriftHiveMetastore_create_catalog_result() noexcept; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + + _ThriftHiveMetastore_create_catalog_result__isset __isset; + + void __set_o1(const AlreadyExistsException& val); + + void __set_o2(const InvalidObjectException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_create_catalog_result & rhs) const; + bool operator != (const ThriftHiveMetastore_create_catalog_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_catalog_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_catalog_presult__isset { + _ThriftHiveMetastore_create_catalog_presult__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_create_catalog_presult__isset; + +class ThriftHiveMetastore_create_catalog_presult { + public: + + + virtual ~ThriftHiveMetastore_create_catalog_presult() noexcept; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + + _ThriftHiveMetastore_create_catalog_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_alter_catalog_args__isset { + _ThriftHiveMetastore_alter_catalog_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_alter_catalog_args__isset; + +class ThriftHiveMetastore_alter_catalog_args { + public: + + ThriftHiveMetastore_alter_catalog_args(const ThriftHiveMetastore_alter_catalog_args&); + ThriftHiveMetastore_alter_catalog_args& operator=(const ThriftHiveMetastore_alter_catalog_args&); + ThriftHiveMetastore_alter_catalog_args() noexcept; + + virtual ~ThriftHiveMetastore_alter_catalog_args() noexcept; + AlterCatalogRequest rqst; + + _ThriftHiveMetastore_alter_catalog_args__isset __isset; + + void __set_rqst(const AlterCatalogRequest& val); + + bool operator == (const ThriftHiveMetastore_alter_catalog_args & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_catalog_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_catalog_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_alter_catalog_pargs { + public: + + + virtual ~ThriftHiveMetastore_alter_catalog_pargs() noexcept; + const AlterCatalogRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_catalog_result__isset { + _ThriftHiveMetastore_alter_catalog_result__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_alter_catalog_result__isset; + +class ThriftHiveMetastore_alter_catalog_result { + public: + + ThriftHiveMetastore_alter_catalog_result(const ThriftHiveMetastore_alter_catalog_result&); + ThriftHiveMetastore_alter_catalog_result& operator=(const ThriftHiveMetastore_alter_catalog_result&); + ThriftHiveMetastore_alter_catalog_result() noexcept; + + virtual ~ThriftHiveMetastore_alter_catalog_result() noexcept; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_alter_catalog_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const InvalidOperationException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_alter_catalog_result & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_catalog_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_catalog_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_catalog_presult__isset { + _ThriftHiveMetastore_alter_catalog_presult__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_alter_catalog_presult__isset; + +class ThriftHiveMetastore_alter_catalog_presult { + public: + + + virtual ~ThriftHiveMetastore_alter_catalog_presult() noexcept; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_alter_catalog_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_catalog_args__isset { + _ThriftHiveMetastore_get_catalog_args__isset() : catName(false) {} + bool catName :1; +} _ThriftHiveMetastore_get_catalog_args__isset; + +class ThriftHiveMetastore_get_catalog_args { + public: + + ThriftHiveMetastore_get_catalog_args(const ThriftHiveMetastore_get_catalog_args&); + ThriftHiveMetastore_get_catalog_args& operator=(const ThriftHiveMetastore_get_catalog_args&); + ThriftHiveMetastore_get_catalog_args() noexcept; + + virtual ~ThriftHiveMetastore_get_catalog_args() noexcept; + GetCatalogRequest catName; + + _ThriftHiveMetastore_get_catalog_args__isset __isset; + + void __set_catName(const GetCatalogRequest& val); + + bool operator == (const ThriftHiveMetastore_get_catalog_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_catalog_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_catalog_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_catalog_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_catalog_pargs() noexcept; + const GetCatalogRequest* catName; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_catalog_result__isset { + _ThriftHiveMetastore_get_catalog_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_catalog_result__isset; + +class ThriftHiveMetastore_get_catalog_result { + public: + + ThriftHiveMetastore_get_catalog_result(const ThriftHiveMetastore_get_catalog_result&); + ThriftHiveMetastore_get_catalog_result& operator=(const ThriftHiveMetastore_get_catalog_result&); + ThriftHiveMetastore_get_catalog_result() noexcept; + + virtual ~ThriftHiveMetastore_get_catalog_result() noexcept; + GetCatalogResponse success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_catalog_result__isset __isset; + + void __set_success(const GetCatalogResponse& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_catalog_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_catalog_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_catalog_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_catalog_presult__isset { + _ThriftHiveMetastore_get_catalog_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_catalog_presult__isset; + +class ThriftHiveMetastore_get_catalog_presult { + public: + + + virtual ~ThriftHiveMetastore_get_catalog_presult() noexcept; + GetCatalogResponse* success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_catalog_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + + +class ThriftHiveMetastore_get_catalogs_args { + public: + + ThriftHiveMetastore_get_catalogs_args(const ThriftHiveMetastore_get_catalogs_args&) noexcept; + ThriftHiveMetastore_get_catalogs_args& operator=(const ThriftHiveMetastore_get_catalogs_args&) noexcept; + ThriftHiveMetastore_get_catalogs_args() noexcept; + + virtual ~ThriftHiveMetastore_get_catalogs_args() noexcept; + + bool operator == (const ThriftHiveMetastore_get_catalogs_args & /* rhs */) const; + bool operator != (const ThriftHiveMetastore_get_catalogs_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_catalogs_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_catalogs_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_catalogs_pargs() noexcept; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_catalogs_result__isset { + _ThriftHiveMetastore_get_catalogs_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_catalogs_result__isset; + +class ThriftHiveMetastore_get_catalogs_result { + public: + + ThriftHiveMetastore_get_catalogs_result(const ThriftHiveMetastore_get_catalogs_result&); + ThriftHiveMetastore_get_catalogs_result& operator=(const ThriftHiveMetastore_get_catalogs_result&); + ThriftHiveMetastore_get_catalogs_result() noexcept; + + virtual ~ThriftHiveMetastore_get_catalogs_result() noexcept; + GetCatalogsResponse success; + MetaException o1; + + _ThriftHiveMetastore_get_catalogs_result__isset __isset; + + void __set_success(const GetCatalogsResponse& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_catalogs_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_catalogs_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_catalogs_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_catalogs_presult__isset { + _ThriftHiveMetastore_get_catalogs_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_catalogs_presult__isset; + +class ThriftHiveMetastore_get_catalogs_presult { + public: + + + virtual ~ThriftHiveMetastore_get_catalogs_presult() noexcept; + GetCatalogsResponse* success; + MetaException o1; + + _ThriftHiveMetastore_get_catalogs_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_catalog_args__isset { + _ThriftHiveMetastore_drop_catalog_args__isset() : catName(false) {} + bool catName :1; +} _ThriftHiveMetastore_drop_catalog_args__isset; + +class ThriftHiveMetastore_drop_catalog_args { + public: + + ThriftHiveMetastore_drop_catalog_args(const ThriftHiveMetastore_drop_catalog_args&); + ThriftHiveMetastore_drop_catalog_args& operator=(const ThriftHiveMetastore_drop_catalog_args&); + ThriftHiveMetastore_drop_catalog_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_catalog_args() noexcept; + DropCatalogRequest catName; + + _ThriftHiveMetastore_drop_catalog_args__isset __isset; + + void __set_catName(const DropCatalogRequest& val); + + bool operator == (const ThriftHiveMetastore_drop_catalog_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_catalog_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_catalog_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_catalog_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_catalog_pargs() noexcept; + const DropCatalogRequest* catName; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_catalog_result__isset { + _ThriftHiveMetastore_drop_catalog_result__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_catalog_result__isset; + +class ThriftHiveMetastore_drop_catalog_result { + public: + + ThriftHiveMetastore_drop_catalog_result(const ThriftHiveMetastore_drop_catalog_result&); + ThriftHiveMetastore_drop_catalog_result& operator=(const ThriftHiveMetastore_drop_catalog_result&); + ThriftHiveMetastore_drop_catalog_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_catalog_result() noexcept; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_catalog_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const InvalidOperationException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_catalog_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_catalog_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_catalog_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_catalog_presult__isset { + _ThriftHiveMetastore_drop_catalog_presult__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_catalog_presult__isset; + +class ThriftHiveMetastore_drop_catalog_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_catalog_presult() noexcept; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_catalog_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_create_database_args__isset { + _ThriftHiveMetastore_create_database_args__isset() : database(false) {} + bool database :1; +} _ThriftHiveMetastore_create_database_args__isset; + +class ThriftHiveMetastore_create_database_args { + public: + + ThriftHiveMetastore_create_database_args(const ThriftHiveMetastore_create_database_args&); + ThriftHiveMetastore_create_database_args& operator=(const ThriftHiveMetastore_create_database_args&); + ThriftHiveMetastore_create_database_args() noexcept; + + virtual ~ThriftHiveMetastore_create_database_args() noexcept; + Database database; + + _ThriftHiveMetastore_create_database_args__isset __isset; + + void __set_database(const Database& val); + + bool operator == (const ThriftHiveMetastore_create_database_args & rhs) const; + bool operator != (const ThriftHiveMetastore_create_database_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_database_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_create_database_pargs { + public: + + + virtual ~ThriftHiveMetastore_create_database_pargs() noexcept; + const Database* database; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_database_result__isset { + _ThriftHiveMetastore_create_database_result__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_create_database_result__isset; + +class ThriftHiveMetastore_create_database_result { + public: + + ThriftHiveMetastore_create_database_result(const ThriftHiveMetastore_create_database_result&); + ThriftHiveMetastore_create_database_result& operator=(const ThriftHiveMetastore_create_database_result&); + ThriftHiveMetastore_create_database_result() noexcept; + + virtual ~ThriftHiveMetastore_create_database_result() noexcept; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + + _ThriftHiveMetastore_create_database_result__isset __isset; + + void __set_o1(const AlreadyExistsException& val); + + void __set_o2(const InvalidObjectException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_create_database_result & rhs) const; + bool operator != (const ThriftHiveMetastore_create_database_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_database_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_database_presult__isset { + _ThriftHiveMetastore_create_database_presult__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_create_database_presult__isset; + +class ThriftHiveMetastore_create_database_presult { + public: + + + virtual ~ThriftHiveMetastore_create_database_presult() noexcept; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + + _ThriftHiveMetastore_create_database_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_create_database_req_args__isset { + _ThriftHiveMetastore_create_database_req_args__isset() : createDatabaseRequest(false) {} + bool createDatabaseRequest :1; +} _ThriftHiveMetastore_create_database_req_args__isset; + +class ThriftHiveMetastore_create_database_req_args { + public: + + ThriftHiveMetastore_create_database_req_args(const ThriftHiveMetastore_create_database_req_args&); + ThriftHiveMetastore_create_database_req_args& operator=(const ThriftHiveMetastore_create_database_req_args&); + ThriftHiveMetastore_create_database_req_args() noexcept; + + virtual ~ThriftHiveMetastore_create_database_req_args() noexcept; + CreateDatabaseRequest createDatabaseRequest; + + _ThriftHiveMetastore_create_database_req_args__isset __isset; + + void __set_createDatabaseRequest(const CreateDatabaseRequest& val); + + bool operator == (const ThriftHiveMetastore_create_database_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_create_database_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_database_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_create_database_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_create_database_req_pargs() noexcept; + const CreateDatabaseRequest* createDatabaseRequest; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_database_req_result__isset { + _ThriftHiveMetastore_create_database_req_result__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_create_database_req_result__isset; + +class ThriftHiveMetastore_create_database_req_result { + public: + + ThriftHiveMetastore_create_database_req_result(const ThriftHiveMetastore_create_database_req_result&); + ThriftHiveMetastore_create_database_req_result& operator=(const ThriftHiveMetastore_create_database_req_result&); + ThriftHiveMetastore_create_database_req_result() noexcept; + + virtual ~ThriftHiveMetastore_create_database_req_result() noexcept; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + + _ThriftHiveMetastore_create_database_req_result__isset __isset; + + void __set_o1(const AlreadyExistsException& val); + + void __set_o2(const InvalidObjectException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_create_database_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_create_database_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_database_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_database_req_presult__isset { + _ThriftHiveMetastore_create_database_req_presult__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_create_database_req_presult__isset; + +class ThriftHiveMetastore_create_database_req_presult { + public: + + + virtual ~ThriftHiveMetastore_create_database_req_presult() noexcept; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + + _ThriftHiveMetastore_create_database_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_database_args__isset { + _ThriftHiveMetastore_get_database_args__isset() : name(false) {} + bool name :1; +} _ThriftHiveMetastore_get_database_args__isset; + +class ThriftHiveMetastore_get_database_args { + public: + + ThriftHiveMetastore_get_database_args(const ThriftHiveMetastore_get_database_args&); + ThriftHiveMetastore_get_database_args& operator=(const ThriftHiveMetastore_get_database_args&); + ThriftHiveMetastore_get_database_args() noexcept; + + virtual ~ThriftHiveMetastore_get_database_args() noexcept; + std::string name; + + _ThriftHiveMetastore_get_database_args__isset __isset; + + void __set_name(const std::string& val); + + bool operator == (const ThriftHiveMetastore_get_database_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_database_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_database_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_database_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_database_pargs() noexcept; + const std::string* name; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_database_result__isset { + _ThriftHiveMetastore_get_database_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_database_result__isset; + +class ThriftHiveMetastore_get_database_result { + public: + + ThriftHiveMetastore_get_database_result(const ThriftHiveMetastore_get_database_result&); + ThriftHiveMetastore_get_database_result& operator=(const ThriftHiveMetastore_get_database_result&); + ThriftHiveMetastore_get_database_result() noexcept; + + virtual ~ThriftHiveMetastore_get_database_result() noexcept; + Database success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_database_result__isset __isset; + + void __set_success(const Database& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_database_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_database_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_database_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_database_presult__isset { + _ThriftHiveMetastore_get_database_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_database_presult__isset; + +class ThriftHiveMetastore_get_database_presult { + public: + + + virtual ~ThriftHiveMetastore_get_database_presult() noexcept; + Database* success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_database_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_database_req_args__isset { + _ThriftHiveMetastore_get_database_req_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_database_req_args__isset; + +class ThriftHiveMetastore_get_database_req_args { + public: + + ThriftHiveMetastore_get_database_req_args(const ThriftHiveMetastore_get_database_req_args&); + ThriftHiveMetastore_get_database_req_args& operator=(const ThriftHiveMetastore_get_database_req_args&); + ThriftHiveMetastore_get_database_req_args() noexcept; + + virtual ~ThriftHiveMetastore_get_database_req_args() noexcept; + GetDatabaseRequest request; + + _ThriftHiveMetastore_get_database_req_args__isset __isset; + + void __set_request(const GetDatabaseRequest& val); + + bool operator == (const ThriftHiveMetastore_get_database_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_database_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_database_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_database_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_database_req_pargs() noexcept; + const GetDatabaseRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_database_req_result__isset { + _ThriftHiveMetastore_get_database_req_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_database_req_result__isset; + +class ThriftHiveMetastore_get_database_req_result { + public: + + ThriftHiveMetastore_get_database_req_result(const ThriftHiveMetastore_get_database_req_result&); + ThriftHiveMetastore_get_database_req_result& operator=(const ThriftHiveMetastore_get_database_req_result&); + ThriftHiveMetastore_get_database_req_result() noexcept; + + virtual ~ThriftHiveMetastore_get_database_req_result() noexcept; + Database success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_database_req_result__isset __isset; + + void __set_success(const Database& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_database_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_database_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_database_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_database_req_presult__isset { + _ThriftHiveMetastore_get_database_req_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_database_req_presult__isset; + +class ThriftHiveMetastore_get_database_req_presult { + public: + + + virtual ~ThriftHiveMetastore_get_database_req_presult() noexcept; + Database* success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_database_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_database_args__isset { + _ThriftHiveMetastore_drop_database_args__isset() : name(false), deleteData(false), cascade(false) {} + bool name :1; + bool deleteData :1; + bool cascade :1; +} _ThriftHiveMetastore_drop_database_args__isset; + +class ThriftHiveMetastore_drop_database_args { + public: + + ThriftHiveMetastore_drop_database_args(const ThriftHiveMetastore_drop_database_args&); + ThriftHiveMetastore_drop_database_args& operator=(const ThriftHiveMetastore_drop_database_args&); + ThriftHiveMetastore_drop_database_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_database_args() noexcept; + std::string name; + bool deleteData; + bool cascade; + + _ThriftHiveMetastore_drop_database_args__isset __isset; + + void __set_name(const std::string& val); + + void __set_deleteData(const bool val); + + void __set_cascade(const bool val); + + bool operator == (const ThriftHiveMetastore_drop_database_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_database_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_database_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_database_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_database_pargs() noexcept; + const std::string* name; + const bool* deleteData; + const bool* cascade; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_database_result__isset { + _ThriftHiveMetastore_drop_database_result__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_database_result__isset; + +class ThriftHiveMetastore_drop_database_result { + public: + + ThriftHiveMetastore_drop_database_result(const ThriftHiveMetastore_drop_database_result&); + ThriftHiveMetastore_drop_database_result& operator=(const ThriftHiveMetastore_drop_database_result&); + ThriftHiveMetastore_drop_database_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_database_result() noexcept; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_database_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const InvalidOperationException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_database_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_database_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_database_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_database_presult__isset { + _ThriftHiveMetastore_drop_database_presult__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_database_presult__isset; + +class ThriftHiveMetastore_drop_database_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_database_presult() noexcept; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_database_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_database_req_args__isset { + _ThriftHiveMetastore_drop_database_req_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_drop_database_req_args__isset; + +class ThriftHiveMetastore_drop_database_req_args { + public: + + ThriftHiveMetastore_drop_database_req_args(const ThriftHiveMetastore_drop_database_req_args&); + ThriftHiveMetastore_drop_database_req_args& operator=(const ThriftHiveMetastore_drop_database_req_args&); + ThriftHiveMetastore_drop_database_req_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_database_req_args() noexcept; + DropDatabaseRequest req; + + _ThriftHiveMetastore_drop_database_req_args__isset __isset; + + void __set_req(const DropDatabaseRequest& val); + + bool operator == (const ThriftHiveMetastore_drop_database_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_database_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_database_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_database_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_database_req_pargs() noexcept; + const DropDatabaseRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_database_req_result__isset { + _ThriftHiveMetastore_drop_database_req_result__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_database_req_result__isset; + +class ThriftHiveMetastore_drop_database_req_result { + public: + + ThriftHiveMetastore_drop_database_req_result(const ThriftHiveMetastore_drop_database_req_result&); + ThriftHiveMetastore_drop_database_req_result& operator=(const ThriftHiveMetastore_drop_database_req_result&); + ThriftHiveMetastore_drop_database_req_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_database_req_result() noexcept; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_database_req_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const InvalidOperationException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_database_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_database_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_database_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_database_req_presult__isset { + _ThriftHiveMetastore_drop_database_req_presult__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_database_req_presult__isset; + +class ThriftHiveMetastore_drop_database_req_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_database_req_presult() noexcept; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_database_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_databases_args__isset { + _ThriftHiveMetastore_get_databases_args__isset() : pattern(false) {} + bool pattern :1; +} _ThriftHiveMetastore_get_databases_args__isset; + +class ThriftHiveMetastore_get_databases_args { + public: + + ThriftHiveMetastore_get_databases_args(const ThriftHiveMetastore_get_databases_args&); + ThriftHiveMetastore_get_databases_args& operator=(const ThriftHiveMetastore_get_databases_args&); + ThriftHiveMetastore_get_databases_args() noexcept; + + virtual ~ThriftHiveMetastore_get_databases_args() noexcept; + std::string pattern; + + _ThriftHiveMetastore_get_databases_args__isset __isset; + + void __set_pattern(const std::string& val); + + bool operator == (const ThriftHiveMetastore_get_databases_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_databases_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_databases_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_databases_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_databases_pargs() noexcept; + const std::string* pattern; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_databases_result__isset { + _ThriftHiveMetastore_get_databases_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_databases_result__isset; + +class ThriftHiveMetastore_get_databases_result { + public: + + ThriftHiveMetastore_get_databases_result(const ThriftHiveMetastore_get_databases_result&); + ThriftHiveMetastore_get_databases_result& operator=(const ThriftHiveMetastore_get_databases_result&); + ThriftHiveMetastore_get_databases_result() noexcept; + + virtual ~ThriftHiveMetastore_get_databases_result() noexcept; + std::vector success; + MetaException o1; + + _ThriftHiveMetastore_get_databases_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_databases_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_databases_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_databases_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_databases_presult__isset { + _ThriftHiveMetastore_get_databases_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_databases_presult__isset; + +class ThriftHiveMetastore_get_databases_presult { + public: + + + virtual ~ThriftHiveMetastore_get_databases_presult() noexcept; + std::vector * success; + MetaException o1; + + _ThriftHiveMetastore_get_databases_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + + +class ThriftHiveMetastore_get_all_databases_args { + public: + + ThriftHiveMetastore_get_all_databases_args(const ThriftHiveMetastore_get_all_databases_args&) noexcept; + ThriftHiveMetastore_get_all_databases_args& operator=(const ThriftHiveMetastore_get_all_databases_args&) noexcept; + ThriftHiveMetastore_get_all_databases_args() noexcept; + + virtual ~ThriftHiveMetastore_get_all_databases_args() noexcept; + + bool operator == (const ThriftHiveMetastore_get_all_databases_args & /* rhs */) const; + bool operator != (const ThriftHiveMetastore_get_all_databases_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_all_databases_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_all_databases_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_all_databases_pargs() noexcept; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_all_databases_result__isset { + _ThriftHiveMetastore_get_all_databases_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_all_databases_result__isset; + +class ThriftHiveMetastore_get_all_databases_result { + public: + + ThriftHiveMetastore_get_all_databases_result(const ThriftHiveMetastore_get_all_databases_result&); + ThriftHiveMetastore_get_all_databases_result& operator=(const ThriftHiveMetastore_get_all_databases_result&); + ThriftHiveMetastore_get_all_databases_result() noexcept; + + virtual ~ThriftHiveMetastore_get_all_databases_result() noexcept; + std::vector success; + MetaException o1; + + _ThriftHiveMetastore_get_all_databases_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_all_databases_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_all_databases_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_all_databases_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_all_databases_presult__isset { + _ThriftHiveMetastore_get_all_databases_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_all_databases_presult__isset; + +class ThriftHiveMetastore_get_all_databases_presult { + public: + + + virtual ~ThriftHiveMetastore_get_all_databases_presult() noexcept; + std::vector * success; + MetaException o1; + + _ThriftHiveMetastore_get_all_databases_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_alter_database_args__isset { + _ThriftHiveMetastore_alter_database_args__isset() : dbname(false), db(false) {} + bool dbname :1; + bool db :1; +} _ThriftHiveMetastore_alter_database_args__isset; + +class ThriftHiveMetastore_alter_database_args { + public: + + ThriftHiveMetastore_alter_database_args(const ThriftHiveMetastore_alter_database_args&); + ThriftHiveMetastore_alter_database_args& operator=(const ThriftHiveMetastore_alter_database_args&); + ThriftHiveMetastore_alter_database_args() noexcept; + + virtual ~ThriftHiveMetastore_alter_database_args() noexcept; + std::string dbname; + Database db; + + _ThriftHiveMetastore_alter_database_args__isset __isset; + + void __set_dbname(const std::string& val); + + void __set_db(const Database& val); + + bool operator == (const ThriftHiveMetastore_alter_database_args & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_database_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_database_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_alter_database_pargs { + public: + + + virtual ~ThriftHiveMetastore_alter_database_pargs() noexcept; + const std::string* dbname; + const Database* db; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_database_result__isset { + _ThriftHiveMetastore_alter_database_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_database_result__isset; + +class ThriftHiveMetastore_alter_database_result { + public: + + ThriftHiveMetastore_alter_database_result(const ThriftHiveMetastore_alter_database_result&); + ThriftHiveMetastore_alter_database_result& operator=(const ThriftHiveMetastore_alter_database_result&); + ThriftHiveMetastore_alter_database_result() noexcept; + + virtual ~ThriftHiveMetastore_alter_database_result() noexcept; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_alter_database_result__isset __isset; + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_alter_database_result & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_database_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_database_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_database_presult__isset { + _ThriftHiveMetastore_alter_database_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_database_presult__isset; + +class ThriftHiveMetastore_alter_database_presult { + public: + + + virtual ~ThriftHiveMetastore_alter_database_presult() noexcept; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_alter_database_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_alter_database_req_args__isset { + _ThriftHiveMetastore_alter_database_req_args__isset() : alterDbReq(false) {} + bool alterDbReq :1; +} _ThriftHiveMetastore_alter_database_req_args__isset; + +class ThriftHiveMetastore_alter_database_req_args { + public: + + ThriftHiveMetastore_alter_database_req_args(const ThriftHiveMetastore_alter_database_req_args&); + ThriftHiveMetastore_alter_database_req_args& operator=(const ThriftHiveMetastore_alter_database_req_args&); + ThriftHiveMetastore_alter_database_req_args() noexcept; + + virtual ~ThriftHiveMetastore_alter_database_req_args() noexcept; + AlterDatabaseRequest alterDbReq; + + _ThriftHiveMetastore_alter_database_req_args__isset __isset; + + void __set_alterDbReq(const AlterDatabaseRequest& val); + + bool operator == (const ThriftHiveMetastore_alter_database_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_database_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_database_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_alter_database_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_alter_database_req_pargs() noexcept; + const AlterDatabaseRequest* alterDbReq; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_database_req_result__isset { + _ThriftHiveMetastore_alter_database_req_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_database_req_result__isset; + +class ThriftHiveMetastore_alter_database_req_result { + public: + + ThriftHiveMetastore_alter_database_req_result(const ThriftHiveMetastore_alter_database_req_result&); + ThriftHiveMetastore_alter_database_req_result& operator=(const ThriftHiveMetastore_alter_database_req_result&); + ThriftHiveMetastore_alter_database_req_result() noexcept; + + virtual ~ThriftHiveMetastore_alter_database_req_result() noexcept; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_alter_database_req_result__isset __isset; + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_alter_database_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_database_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_database_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_database_req_presult__isset { + _ThriftHiveMetastore_alter_database_req_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_database_req_presult__isset; + +class ThriftHiveMetastore_alter_database_req_presult { + public: + + + virtual ~ThriftHiveMetastore_alter_database_req_presult() noexcept; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_alter_database_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_create_dataconnector_req_args__isset { + _ThriftHiveMetastore_create_dataconnector_req_args__isset() : connectorReq(false) {} + bool connectorReq :1; +} _ThriftHiveMetastore_create_dataconnector_req_args__isset; + +class ThriftHiveMetastore_create_dataconnector_req_args { + public: + + ThriftHiveMetastore_create_dataconnector_req_args(const ThriftHiveMetastore_create_dataconnector_req_args&); + ThriftHiveMetastore_create_dataconnector_req_args& operator=(const ThriftHiveMetastore_create_dataconnector_req_args&); + ThriftHiveMetastore_create_dataconnector_req_args() noexcept; + + virtual ~ThriftHiveMetastore_create_dataconnector_req_args() noexcept; + CreateDataConnectorRequest connectorReq; + + _ThriftHiveMetastore_create_dataconnector_req_args__isset __isset; + + void __set_connectorReq(const CreateDataConnectorRequest& val); + + bool operator == (const ThriftHiveMetastore_create_dataconnector_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_create_dataconnector_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_dataconnector_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_create_dataconnector_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_create_dataconnector_req_pargs() noexcept; + const CreateDataConnectorRequest* connectorReq; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_dataconnector_req_result__isset { + _ThriftHiveMetastore_create_dataconnector_req_result__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_create_dataconnector_req_result__isset; + +class ThriftHiveMetastore_create_dataconnector_req_result { + public: + + ThriftHiveMetastore_create_dataconnector_req_result(const ThriftHiveMetastore_create_dataconnector_req_result&); + ThriftHiveMetastore_create_dataconnector_req_result& operator=(const ThriftHiveMetastore_create_dataconnector_req_result&); + ThriftHiveMetastore_create_dataconnector_req_result() noexcept; + + virtual ~ThriftHiveMetastore_create_dataconnector_req_result() noexcept; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + + _ThriftHiveMetastore_create_dataconnector_req_result__isset __isset; + + void __set_o1(const AlreadyExistsException& val); + + void __set_o2(const InvalidObjectException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_create_dataconnector_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_create_dataconnector_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_dataconnector_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_dataconnector_req_presult__isset { + _ThriftHiveMetastore_create_dataconnector_req_presult__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_create_dataconnector_req_presult__isset; + +class ThriftHiveMetastore_create_dataconnector_req_presult { + public: + + + virtual ~ThriftHiveMetastore_create_dataconnector_req_presult() noexcept; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + + _ThriftHiveMetastore_create_dataconnector_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_dataconnector_req_args__isset { + _ThriftHiveMetastore_get_dataconnector_req_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_dataconnector_req_args__isset; + +class ThriftHiveMetastore_get_dataconnector_req_args { + public: + + ThriftHiveMetastore_get_dataconnector_req_args(const ThriftHiveMetastore_get_dataconnector_req_args&); + ThriftHiveMetastore_get_dataconnector_req_args& operator=(const ThriftHiveMetastore_get_dataconnector_req_args&); + ThriftHiveMetastore_get_dataconnector_req_args() noexcept; + + virtual ~ThriftHiveMetastore_get_dataconnector_req_args() noexcept; + GetDataConnectorRequest request; + + _ThriftHiveMetastore_get_dataconnector_req_args__isset __isset; + + void __set_request(const GetDataConnectorRequest& val); + + bool operator == (const ThriftHiveMetastore_get_dataconnector_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_dataconnector_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_dataconnector_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_dataconnector_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_dataconnector_req_pargs() noexcept; + const GetDataConnectorRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_dataconnector_req_result__isset { + _ThriftHiveMetastore_get_dataconnector_req_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_dataconnector_req_result__isset; + +class ThriftHiveMetastore_get_dataconnector_req_result { + public: + + ThriftHiveMetastore_get_dataconnector_req_result(const ThriftHiveMetastore_get_dataconnector_req_result&); + ThriftHiveMetastore_get_dataconnector_req_result& operator=(const ThriftHiveMetastore_get_dataconnector_req_result&); + ThriftHiveMetastore_get_dataconnector_req_result() noexcept; + + virtual ~ThriftHiveMetastore_get_dataconnector_req_result() noexcept; + DataConnector success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_dataconnector_req_result__isset __isset; + + void __set_success(const DataConnector& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_dataconnector_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_dataconnector_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_dataconnector_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_dataconnector_req_presult__isset { + _ThriftHiveMetastore_get_dataconnector_req_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_dataconnector_req_presult__isset; + +class ThriftHiveMetastore_get_dataconnector_req_presult { + public: + + + virtual ~ThriftHiveMetastore_get_dataconnector_req_presult() noexcept; + DataConnector* success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_dataconnector_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_dataconnector_req_args__isset { + _ThriftHiveMetastore_drop_dataconnector_req_args__isset() : dropDcReq(false) {} + bool dropDcReq :1; +} _ThriftHiveMetastore_drop_dataconnector_req_args__isset; + +class ThriftHiveMetastore_drop_dataconnector_req_args { + public: + + ThriftHiveMetastore_drop_dataconnector_req_args(const ThriftHiveMetastore_drop_dataconnector_req_args&); + ThriftHiveMetastore_drop_dataconnector_req_args& operator=(const ThriftHiveMetastore_drop_dataconnector_req_args&); + ThriftHiveMetastore_drop_dataconnector_req_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_dataconnector_req_args() noexcept; + DropDataConnectorRequest dropDcReq; + + _ThriftHiveMetastore_drop_dataconnector_req_args__isset __isset; + + void __set_dropDcReq(const DropDataConnectorRequest& val); + + bool operator == (const ThriftHiveMetastore_drop_dataconnector_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_dataconnector_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_dataconnector_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_dataconnector_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_dataconnector_req_pargs() noexcept; + const DropDataConnectorRequest* dropDcReq; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_dataconnector_req_result__isset { + _ThriftHiveMetastore_drop_dataconnector_req_result__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_dataconnector_req_result__isset; + +class ThriftHiveMetastore_drop_dataconnector_req_result { + public: + + ThriftHiveMetastore_drop_dataconnector_req_result(const ThriftHiveMetastore_drop_dataconnector_req_result&); + ThriftHiveMetastore_drop_dataconnector_req_result& operator=(const ThriftHiveMetastore_drop_dataconnector_req_result&); + ThriftHiveMetastore_drop_dataconnector_req_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_dataconnector_req_result() noexcept; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_dataconnector_req_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const InvalidOperationException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_dataconnector_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_dataconnector_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_dataconnector_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_dataconnector_req_presult__isset { + _ThriftHiveMetastore_drop_dataconnector_req_presult__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_dataconnector_req_presult__isset; + +class ThriftHiveMetastore_drop_dataconnector_req_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_dataconnector_req_presult() noexcept; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_dataconnector_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + + +class ThriftHiveMetastore_get_dataconnectors_args { + public: + + ThriftHiveMetastore_get_dataconnectors_args(const ThriftHiveMetastore_get_dataconnectors_args&) noexcept; + ThriftHiveMetastore_get_dataconnectors_args& operator=(const ThriftHiveMetastore_get_dataconnectors_args&) noexcept; + ThriftHiveMetastore_get_dataconnectors_args() noexcept; + + virtual ~ThriftHiveMetastore_get_dataconnectors_args() noexcept; + + bool operator == (const ThriftHiveMetastore_get_dataconnectors_args & /* rhs */) const; + bool operator != (const ThriftHiveMetastore_get_dataconnectors_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_dataconnectors_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_dataconnectors_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_dataconnectors_pargs() noexcept; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_dataconnectors_result__isset { + _ThriftHiveMetastore_get_dataconnectors_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_dataconnectors_result__isset; + +class ThriftHiveMetastore_get_dataconnectors_result { + public: + + ThriftHiveMetastore_get_dataconnectors_result(const ThriftHiveMetastore_get_dataconnectors_result&); + ThriftHiveMetastore_get_dataconnectors_result& operator=(const ThriftHiveMetastore_get_dataconnectors_result&); + ThriftHiveMetastore_get_dataconnectors_result() noexcept; + + virtual ~ThriftHiveMetastore_get_dataconnectors_result() noexcept; + std::vector success; + MetaException o1; + + _ThriftHiveMetastore_get_dataconnectors_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_dataconnectors_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_dataconnectors_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_dataconnectors_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_dataconnectors_presult__isset { + _ThriftHiveMetastore_get_dataconnectors_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_dataconnectors_presult__isset; + +class ThriftHiveMetastore_get_dataconnectors_presult { + public: + + + virtual ~ThriftHiveMetastore_get_dataconnectors_presult() noexcept; + std::vector * success; + MetaException o1; + + _ThriftHiveMetastore_get_dataconnectors_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_alter_dataconnector_req_args__isset { + _ThriftHiveMetastore_alter_dataconnector_req_args__isset() : alterReq(false) {} + bool alterReq :1; +} _ThriftHiveMetastore_alter_dataconnector_req_args__isset; + +class ThriftHiveMetastore_alter_dataconnector_req_args { + public: + + ThriftHiveMetastore_alter_dataconnector_req_args(const ThriftHiveMetastore_alter_dataconnector_req_args&); + ThriftHiveMetastore_alter_dataconnector_req_args& operator=(const ThriftHiveMetastore_alter_dataconnector_req_args&); + ThriftHiveMetastore_alter_dataconnector_req_args() noexcept; + + virtual ~ThriftHiveMetastore_alter_dataconnector_req_args() noexcept; + AlterDataConnectorRequest alterReq; + + _ThriftHiveMetastore_alter_dataconnector_req_args__isset __isset; + + void __set_alterReq(const AlterDataConnectorRequest& val); + + bool operator == (const ThriftHiveMetastore_alter_dataconnector_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_dataconnector_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_dataconnector_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_alter_dataconnector_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_alter_dataconnector_req_pargs() noexcept; + const AlterDataConnectorRequest* alterReq; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_dataconnector_req_result__isset { + _ThriftHiveMetastore_alter_dataconnector_req_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_dataconnector_req_result__isset; + +class ThriftHiveMetastore_alter_dataconnector_req_result { + public: + + ThriftHiveMetastore_alter_dataconnector_req_result(const ThriftHiveMetastore_alter_dataconnector_req_result&); + ThriftHiveMetastore_alter_dataconnector_req_result& operator=(const ThriftHiveMetastore_alter_dataconnector_req_result&); + ThriftHiveMetastore_alter_dataconnector_req_result() noexcept; + + virtual ~ThriftHiveMetastore_alter_dataconnector_req_result() noexcept; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_alter_dataconnector_req_result__isset __isset; + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_alter_dataconnector_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_dataconnector_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_dataconnector_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_dataconnector_req_presult__isset { + _ThriftHiveMetastore_alter_dataconnector_req_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_dataconnector_req_presult__isset; + +class ThriftHiveMetastore_alter_dataconnector_req_presult { + public: + + + virtual ~ThriftHiveMetastore_alter_dataconnector_req_presult() noexcept; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_alter_dataconnector_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_type_args__isset { + _ThriftHiveMetastore_get_type_args__isset() : name(false) {} + bool name :1; +} _ThriftHiveMetastore_get_type_args__isset; + +class ThriftHiveMetastore_get_type_args { + public: + + ThriftHiveMetastore_get_type_args(const ThriftHiveMetastore_get_type_args&); + ThriftHiveMetastore_get_type_args& operator=(const ThriftHiveMetastore_get_type_args&); + ThriftHiveMetastore_get_type_args() noexcept; + + virtual ~ThriftHiveMetastore_get_type_args() noexcept; + std::string name; + + _ThriftHiveMetastore_get_type_args__isset __isset; + + void __set_name(const std::string& val); + + bool operator == (const ThriftHiveMetastore_get_type_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_type_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_type_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_type_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_type_pargs() noexcept; + const std::string* name; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_type_result__isset { + _ThriftHiveMetastore_get_type_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_type_result__isset; + +class ThriftHiveMetastore_get_type_result { + public: + + ThriftHiveMetastore_get_type_result(const ThriftHiveMetastore_get_type_result&); + ThriftHiveMetastore_get_type_result& operator=(const ThriftHiveMetastore_get_type_result&); + ThriftHiveMetastore_get_type_result() noexcept; + + virtual ~ThriftHiveMetastore_get_type_result() noexcept; + Type success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_type_result__isset __isset; + + void __set_success(const Type& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_type_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_type_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_type_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_type_presult__isset { + _ThriftHiveMetastore_get_type_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_type_presult__isset; + +class ThriftHiveMetastore_get_type_presult { + public: + + + virtual ~ThriftHiveMetastore_get_type_presult() noexcept; + Type* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_type_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_create_type_args__isset { + _ThriftHiveMetastore_create_type_args__isset() : type(false) {} + bool type :1; +} _ThriftHiveMetastore_create_type_args__isset; + +class ThriftHiveMetastore_create_type_args { + public: + + ThriftHiveMetastore_create_type_args(const ThriftHiveMetastore_create_type_args&); + ThriftHiveMetastore_create_type_args& operator=(const ThriftHiveMetastore_create_type_args&); + ThriftHiveMetastore_create_type_args() noexcept; + + virtual ~ThriftHiveMetastore_create_type_args() noexcept; + Type type; + + _ThriftHiveMetastore_create_type_args__isset __isset; + + void __set_type(const Type& val); + + bool operator == (const ThriftHiveMetastore_create_type_args & rhs) const; + bool operator != (const ThriftHiveMetastore_create_type_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_type_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_create_type_pargs { + public: + + + virtual ~ThriftHiveMetastore_create_type_pargs() noexcept; + const Type* type; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_type_result__isset { + _ThriftHiveMetastore_create_type_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_create_type_result__isset; + +class ThriftHiveMetastore_create_type_result { + public: + + ThriftHiveMetastore_create_type_result(const ThriftHiveMetastore_create_type_result&); + ThriftHiveMetastore_create_type_result& operator=(const ThriftHiveMetastore_create_type_result&); + ThriftHiveMetastore_create_type_result() noexcept; + + virtual ~ThriftHiveMetastore_create_type_result() noexcept; + bool success; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + + _ThriftHiveMetastore_create_type_result__isset __isset; + + void __set_success(const bool val); + + void __set_o1(const AlreadyExistsException& val); + + void __set_o2(const InvalidObjectException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_create_type_result & rhs) const; + bool operator != (const ThriftHiveMetastore_create_type_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_type_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_type_presult__isset { + _ThriftHiveMetastore_create_type_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_create_type_presult__isset; + +class ThriftHiveMetastore_create_type_presult { + public: + + + virtual ~ThriftHiveMetastore_create_type_presult() noexcept; + bool* success; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + + _ThriftHiveMetastore_create_type_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_type_args__isset { + _ThriftHiveMetastore_drop_type_args__isset() : type(false) {} + bool type :1; +} _ThriftHiveMetastore_drop_type_args__isset; + +class ThriftHiveMetastore_drop_type_args { + public: + + ThriftHiveMetastore_drop_type_args(const ThriftHiveMetastore_drop_type_args&); + ThriftHiveMetastore_drop_type_args& operator=(const ThriftHiveMetastore_drop_type_args&); + ThriftHiveMetastore_drop_type_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_type_args() noexcept; + std::string type; + + _ThriftHiveMetastore_drop_type_args__isset __isset; + + void __set_type(const std::string& val); + + bool operator == (const ThriftHiveMetastore_drop_type_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_type_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_type_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_type_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_type_pargs() noexcept; + const std::string* type; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_type_result__isset { + _ThriftHiveMetastore_drop_type_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_drop_type_result__isset; + +class ThriftHiveMetastore_drop_type_result { + public: + + ThriftHiveMetastore_drop_type_result(const ThriftHiveMetastore_drop_type_result&); + ThriftHiveMetastore_drop_type_result& operator=(const ThriftHiveMetastore_drop_type_result&); + ThriftHiveMetastore_drop_type_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_type_result() noexcept; + bool success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_drop_type_result__isset __isset; + + void __set_success(const bool val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_drop_type_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_type_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_type_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_type_presult__isset { + _ThriftHiveMetastore_drop_type_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_drop_type_presult__isset; + +class ThriftHiveMetastore_drop_type_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_type_presult() noexcept; + bool* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_drop_type_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_type_all_args__isset { + _ThriftHiveMetastore_get_type_all_args__isset() : name(false) {} + bool name :1; +} _ThriftHiveMetastore_get_type_all_args__isset; + +class ThriftHiveMetastore_get_type_all_args { + public: + + ThriftHiveMetastore_get_type_all_args(const ThriftHiveMetastore_get_type_all_args&); + ThriftHiveMetastore_get_type_all_args& operator=(const ThriftHiveMetastore_get_type_all_args&); + ThriftHiveMetastore_get_type_all_args() noexcept; + + virtual ~ThriftHiveMetastore_get_type_all_args() noexcept; + std::string name; + + _ThriftHiveMetastore_get_type_all_args__isset __isset; + + void __set_name(const std::string& val); + + bool operator == (const ThriftHiveMetastore_get_type_all_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_type_all_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_type_all_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_type_all_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_type_all_pargs() noexcept; + const std::string* name; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_type_all_result__isset { + _ThriftHiveMetastore_get_type_all_result__isset() : success(false), o2(false) {} + bool success :1; + bool o2 :1; +} _ThriftHiveMetastore_get_type_all_result__isset; + +class ThriftHiveMetastore_get_type_all_result { + public: + + ThriftHiveMetastore_get_type_all_result(const ThriftHiveMetastore_get_type_all_result&); + ThriftHiveMetastore_get_type_all_result& operator=(const ThriftHiveMetastore_get_type_all_result&); + ThriftHiveMetastore_get_type_all_result() noexcept; + + virtual ~ThriftHiveMetastore_get_type_all_result() noexcept; + std::map success; + MetaException o2; + + _ThriftHiveMetastore_get_type_all_result__isset __isset; + + void __set_success(const std::map & val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_type_all_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_type_all_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_type_all_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_type_all_presult__isset { + _ThriftHiveMetastore_get_type_all_presult__isset() : success(false), o2(false) {} + bool success :1; + bool o2 :1; +} _ThriftHiveMetastore_get_type_all_presult__isset; + +class ThriftHiveMetastore_get_type_all_presult { + public: + + + virtual ~ThriftHiveMetastore_get_type_all_presult() noexcept; + std::map * success; + MetaException o2; + + _ThriftHiveMetastore_get_type_all_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_fields_args__isset { + _ThriftHiveMetastore_get_fields_args__isset() : db_name(false), table_name(false) {} + bool db_name :1; + bool table_name :1; +} _ThriftHiveMetastore_get_fields_args__isset; + +class ThriftHiveMetastore_get_fields_args { + public: + + ThriftHiveMetastore_get_fields_args(const ThriftHiveMetastore_get_fields_args&); + ThriftHiveMetastore_get_fields_args& operator=(const ThriftHiveMetastore_get_fields_args&); + ThriftHiveMetastore_get_fields_args() noexcept; + + virtual ~ThriftHiveMetastore_get_fields_args() noexcept; + std::string db_name; + std::string table_name; + + _ThriftHiveMetastore_get_fields_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_table_name(const std::string& val); + + bool operator == (const ThriftHiveMetastore_get_fields_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_fields_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_fields_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_fields_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_fields_pargs() noexcept; + const std::string* db_name; + const std::string* table_name; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_fields_result__isset { + _ThriftHiveMetastore_get_fields_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_get_fields_result__isset; + +class ThriftHiveMetastore_get_fields_result { + public: + + ThriftHiveMetastore_get_fields_result(const ThriftHiveMetastore_get_fields_result&); + ThriftHiveMetastore_get_fields_result& operator=(const ThriftHiveMetastore_get_fields_result&); + ThriftHiveMetastore_get_fields_result() noexcept; + + virtual ~ThriftHiveMetastore_get_fields_result() noexcept; + std::vector success; + MetaException o1; + UnknownTableException o2; + UnknownDBException o3; + + _ThriftHiveMetastore_get_fields_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + void __set_o2(const UnknownTableException& val); + + void __set_o3(const UnknownDBException& val); + + bool operator == (const ThriftHiveMetastore_get_fields_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_fields_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_fields_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_fields_presult__isset { + _ThriftHiveMetastore_get_fields_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_get_fields_presult__isset; + +class ThriftHiveMetastore_get_fields_presult { + public: + + + virtual ~ThriftHiveMetastore_get_fields_presult() noexcept; + std::vector * success; + MetaException o1; + UnknownTableException o2; + UnknownDBException o3; + + _ThriftHiveMetastore_get_fields_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_fields_with_environment_context_args__isset { + _ThriftHiveMetastore_get_fields_with_environment_context_args__isset() : db_name(false), table_name(false), environment_context(false) {} + bool db_name :1; + bool table_name :1; + bool environment_context :1; +} _ThriftHiveMetastore_get_fields_with_environment_context_args__isset; + +class ThriftHiveMetastore_get_fields_with_environment_context_args { + public: + + ThriftHiveMetastore_get_fields_with_environment_context_args(const ThriftHiveMetastore_get_fields_with_environment_context_args&); + ThriftHiveMetastore_get_fields_with_environment_context_args& operator=(const ThriftHiveMetastore_get_fields_with_environment_context_args&); + ThriftHiveMetastore_get_fields_with_environment_context_args() noexcept; + + virtual ~ThriftHiveMetastore_get_fields_with_environment_context_args() noexcept; + std::string db_name; + std::string table_name; + EnvironmentContext environment_context; + + _ThriftHiveMetastore_get_fields_with_environment_context_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_table_name(const std::string& val); + + void __set_environment_context(const EnvironmentContext& val); + + bool operator == (const ThriftHiveMetastore_get_fields_with_environment_context_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_fields_with_environment_context_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_fields_with_environment_context_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_fields_with_environment_context_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_fields_with_environment_context_pargs() noexcept; + const std::string* db_name; + const std::string* table_name; + const EnvironmentContext* environment_context; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_fields_with_environment_context_result__isset { + _ThriftHiveMetastore_get_fields_with_environment_context_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_get_fields_with_environment_context_result__isset; + +class ThriftHiveMetastore_get_fields_with_environment_context_result { + public: + + ThriftHiveMetastore_get_fields_with_environment_context_result(const ThriftHiveMetastore_get_fields_with_environment_context_result&); + ThriftHiveMetastore_get_fields_with_environment_context_result& operator=(const ThriftHiveMetastore_get_fields_with_environment_context_result&); + ThriftHiveMetastore_get_fields_with_environment_context_result() noexcept; + + virtual ~ThriftHiveMetastore_get_fields_with_environment_context_result() noexcept; + std::vector success; + MetaException o1; + UnknownTableException o2; + UnknownDBException o3; + + _ThriftHiveMetastore_get_fields_with_environment_context_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + void __set_o2(const UnknownTableException& val); + + void __set_o3(const UnknownDBException& val); + + bool operator == (const ThriftHiveMetastore_get_fields_with_environment_context_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_fields_with_environment_context_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_fields_with_environment_context_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_fields_with_environment_context_presult__isset { + _ThriftHiveMetastore_get_fields_with_environment_context_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_get_fields_with_environment_context_presult__isset; + +class ThriftHiveMetastore_get_fields_with_environment_context_presult { + public: + + + virtual ~ThriftHiveMetastore_get_fields_with_environment_context_presult() noexcept; + std::vector * success; + MetaException o1; + UnknownTableException o2; + UnknownDBException o3; + + _ThriftHiveMetastore_get_fields_with_environment_context_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_fields_req_args__isset { + _ThriftHiveMetastore_get_fields_req_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_get_fields_req_args__isset; + +class ThriftHiveMetastore_get_fields_req_args { + public: + + ThriftHiveMetastore_get_fields_req_args(const ThriftHiveMetastore_get_fields_req_args&); + ThriftHiveMetastore_get_fields_req_args& operator=(const ThriftHiveMetastore_get_fields_req_args&); + ThriftHiveMetastore_get_fields_req_args() noexcept; + + virtual ~ThriftHiveMetastore_get_fields_req_args() noexcept; + GetFieldsRequest req; + + _ThriftHiveMetastore_get_fields_req_args__isset __isset; + + void __set_req(const GetFieldsRequest& val); + + bool operator == (const ThriftHiveMetastore_get_fields_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_fields_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_fields_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_fields_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_fields_req_pargs() noexcept; + const GetFieldsRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_fields_req_result__isset { + _ThriftHiveMetastore_get_fields_req_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_get_fields_req_result__isset; + +class ThriftHiveMetastore_get_fields_req_result { + public: + + ThriftHiveMetastore_get_fields_req_result(const ThriftHiveMetastore_get_fields_req_result&); + ThriftHiveMetastore_get_fields_req_result& operator=(const ThriftHiveMetastore_get_fields_req_result&); + ThriftHiveMetastore_get_fields_req_result() noexcept; + + virtual ~ThriftHiveMetastore_get_fields_req_result() noexcept; + GetFieldsResponse success; + MetaException o1; + UnknownTableException o2; + UnknownDBException o3; + + _ThriftHiveMetastore_get_fields_req_result__isset __isset; + + void __set_success(const GetFieldsResponse& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const UnknownTableException& val); + + void __set_o3(const UnknownDBException& val); + + bool operator == (const ThriftHiveMetastore_get_fields_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_fields_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_fields_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_fields_req_presult__isset { + _ThriftHiveMetastore_get_fields_req_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_get_fields_req_presult__isset; + +class ThriftHiveMetastore_get_fields_req_presult { + public: + + + virtual ~ThriftHiveMetastore_get_fields_req_presult() noexcept; + GetFieldsResponse* success; + MetaException o1; + UnknownTableException o2; + UnknownDBException o3; + + _ThriftHiveMetastore_get_fields_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_schema_args__isset { + _ThriftHiveMetastore_get_schema_args__isset() : db_name(false), table_name(false) {} + bool db_name :1; + bool table_name :1; +} _ThriftHiveMetastore_get_schema_args__isset; + +class ThriftHiveMetastore_get_schema_args { + public: + + ThriftHiveMetastore_get_schema_args(const ThriftHiveMetastore_get_schema_args&); + ThriftHiveMetastore_get_schema_args& operator=(const ThriftHiveMetastore_get_schema_args&); + ThriftHiveMetastore_get_schema_args() noexcept; + + virtual ~ThriftHiveMetastore_get_schema_args() noexcept; + std::string db_name; + std::string table_name; + + _ThriftHiveMetastore_get_schema_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_table_name(const std::string& val); + + bool operator == (const ThriftHiveMetastore_get_schema_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_schema_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_schema_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_schema_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_schema_pargs() noexcept; + const std::string* db_name; + const std::string* table_name; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_schema_result__isset { + _ThriftHiveMetastore_get_schema_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_get_schema_result__isset; + +class ThriftHiveMetastore_get_schema_result { + public: + + ThriftHiveMetastore_get_schema_result(const ThriftHiveMetastore_get_schema_result&); + ThriftHiveMetastore_get_schema_result& operator=(const ThriftHiveMetastore_get_schema_result&); + ThriftHiveMetastore_get_schema_result() noexcept; + + virtual ~ThriftHiveMetastore_get_schema_result() noexcept; + std::vector success; + MetaException o1; + UnknownTableException o2; + UnknownDBException o3; + + _ThriftHiveMetastore_get_schema_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + void __set_o2(const UnknownTableException& val); + + void __set_o3(const UnknownDBException& val); + + bool operator == (const ThriftHiveMetastore_get_schema_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_schema_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_schema_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_schema_presult__isset { + _ThriftHiveMetastore_get_schema_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_get_schema_presult__isset; + +class ThriftHiveMetastore_get_schema_presult { + public: + + + virtual ~ThriftHiveMetastore_get_schema_presult() noexcept; + std::vector * success; + MetaException o1; + UnknownTableException o2; + UnknownDBException o3; + + _ThriftHiveMetastore_get_schema_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_schema_with_environment_context_args__isset { + _ThriftHiveMetastore_get_schema_with_environment_context_args__isset() : db_name(false), table_name(false), environment_context(false) {} + bool db_name :1; + bool table_name :1; + bool environment_context :1; +} _ThriftHiveMetastore_get_schema_with_environment_context_args__isset; + +class ThriftHiveMetastore_get_schema_with_environment_context_args { + public: + + ThriftHiveMetastore_get_schema_with_environment_context_args(const ThriftHiveMetastore_get_schema_with_environment_context_args&); + ThriftHiveMetastore_get_schema_with_environment_context_args& operator=(const ThriftHiveMetastore_get_schema_with_environment_context_args&); + ThriftHiveMetastore_get_schema_with_environment_context_args() noexcept; + + virtual ~ThriftHiveMetastore_get_schema_with_environment_context_args() noexcept; + std::string db_name; + std::string table_name; + EnvironmentContext environment_context; + + _ThriftHiveMetastore_get_schema_with_environment_context_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_table_name(const std::string& val); + + void __set_environment_context(const EnvironmentContext& val); + + bool operator == (const ThriftHiveMetastore_get_schema_with_environment_context_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_schema_with_environment_context_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_schema_with_environment_context_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_schema_with_environment_context_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_schema_with_environment_context_pargs() noexcept; + const std::string* db_name; + const std::string* table_name; + const EnvironmentContext* environment_context; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_schema_with_environment_context_result__isset { + _ThriftHiveMetastore_get_schema_with_environment_context_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_get_schema_with_environment_context_result__isset; + +class ThriftHiveMetastore_get_schema_with_environment_context_result { + public: + + ThriftHiveMetastore_get_schema_with_environment_context_result(const ThriftHiveMetastore_get_schema_with_environment_context_result&); + ThriftHiveMetastore_get_schema_with_environment_context_result& operator=(const ThriftHiveMetastore_get_schema_with_environment_context_result&); + ThriftHiveMetastore_get_schema_with_environment_context_result() noexcept; + + virtual ~ThriftHiveMetastore_get_schema_with_environment_context_result() noexcept; + std::vector success; + MetaException o1; + UnknownTableException o2; + UnknownDBException o3; + + _ThriftHiveMetastore_get_schema_with_environment_context_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + void __set_o2(const UnknownTableException& val); + + void __set_o3(const UnknownDBException& val); + + bool operator == (const ThriftHiveMetastore_get_schema_with_environment_context_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_schema_with_environment_context_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_schema_with_environment_context_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_schema_with_environment_context_presult__isset { + _ThriftHiveMetastore_get_schema_with_environment_context_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_get_schema_with_environment_context_presult__isset; + +class ThriftHiveMetastore_get_schema_with_environment_context_presult { + public: + + + virtual ~ThriftHiveMetastore_get_schema_with_environment_context_presult() noexcept; + std::vector * success; + MetaException o1; + UnknownTableException o2; + UnknownDBException o3; + + _ThriftHiveMetastore_get_schema_with_environment_context_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_schema_req_args__isset { + _ThriftHiveMetastore_get_schema_req_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_get_schema_req_args__isset; + +class ThriftHiveMetastore_get_schema_req_args { + public: + + ThriftHiveMetastore_get_schema_req_args(const ThriftHiveMetastore_get_schema_req_args&); + ThriftHiveMetastore_get_schema_req_args& operator=(const ThriftHiveMetastore_get_schema_req_args&); + ThriftHiveMetastore_get_schema_req_args() noexcept; + + virtual ~ThriftHiveMetastore_get_schema_req_args() noexcept; + GetSchemaRequest req; + + _ThriftHiveMetastore_get_schema_req_args__isset __isset; + + void __set_req(const GetSchemaRequest& val); + + bool operator == (const ThriftHiveMetastore_get_schema_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_schema_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_schema_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_schema_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_schema_req_pargs() noexcept; + const GetSchemaRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_schema_req_result__isset { + _ThriftHiveMetastore_get_schema_req_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_get_schema_req_result__isset; + +class ThriftHiveMetastore_get_schema_req_result { + public: + + ThriftHiveMetastore_get_schema_req_result(const ThriftHiveMetastore_get_schema_req_result&); + ThriftHiveMetastore_get_schema_req_result& operator=(const ThriftHiveMetastore_get_schema_req_result&); + ThriftHiveMetastore_get_schema_req_result() noexcept; + + virtual ~ThriftHiveMetastore_get_schema_req_result() noexcept; + GetSchemaResponse success; + MetaException o1; + UnknownTableException o2; + UnknownDBException o3; + + _ThriftHiveMetastore_get_schema_req_result__isset __isset; + + void __set_success(const GetSchemaResponse& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const UnknownTableException& val); + + void __set_o3(const UnknownDBException& val); + + bool operator == (const ThriftHiveMetastore_get_schema_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_schema_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_schema_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_schema_req_presult__isset { + _ThriftHiveMetastore_get_schema_req_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_get_schema_req_presult__isset; + +class ThriftHiveMetastore_get_schema_req_presult { + public: + + + virtual ~ThriftHiveMetastore_get_schema_req_presult() noexcept; + GetSchemaResponse* success; + MetaException o1; + UnknownTableException o2; + UnknownDBException o3; + + _ThriftHiveMetastore_get_schema_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_create_table_args__isset { + _ThriftHiveMetastore_create_table_args__isset() : tbl(false) {} + bool tbl :1; +} _ThriftHiveMetastore_create_table_args__isset; + +class ThriftHiveMetastore_create_table_args { + public: + + ThriftHiveMetastore_create_table_args(const ThriftHiveMetastore_create_table_args&); + ThriftHiveMetastore_create_table_args& operator=(const ThriftHiveMetastore_create_table_args&); + ThriftHiveMetastore_create_table_args() noexcept; + + virtual ~ThriftHiveMetastore_create_table_args() noexcept; + Table tbl; + + _ThriftHiveMetastore_create_table_args__isset __isset; + + void __set_tbl(const Table& val); + + bool operator == (const ThriftHiveMetastore_create_table_args & rhs) const; + bool operator != (const ThriftHiveMetastore_create_table_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_table_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_create_table_pargs { + public: + + + virtual ~ThriftHiveMetastore_create_table_pargs() noexcept; + const Table* tbl; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_table_result__isset { + _ThriftHiveMetastore_create_table_result__isset() : o1(false), o2(false), o3(false), o4(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_create_table_result__isset; + +class ThriftHiveMetastore_create_table_result { + public: + + ThriftHiveMetastore_create_table_result(const ThriftHiveMetastore_create_table_result&); + ThriftHiveMetastore_create_table_result& operator=(const ThriftHiveMetastore_create_table_result&); + ThriftHiveMetastore_create_table_result() noexcept; + + virtual ~ThriftHiveMetastore_create_table_result() noexcept; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + NoSuchObjectException o4; + + _ThriftHiveMetastore_create_table_result__isset __isset; + + void __set_o1(const AlreadyExistsException& val); + + void __set_o2(const InvalidObjectException& val); + + void __set_o3(const MetaException& val); + + void __set_o4(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_create_table_result & rhs) const; + bool operator != (const ThriftHiveMetastore_create_table_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_table_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_table_presult__isset { + _ThriftHiveMetastore_create_table_presult__isset() : o1(false), o2(false), o3(false), o4(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_create_table_presult__isset; + +class ThriftHiveMetastore_create_table_presult { + public: + + + virtual ~ThriftHiveMetastore_create_table_presult() noexcept; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + NoSuchObjectException o4; + + _ThriftHiveMetastore_create_table_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_create_table_with_environment_context_args__isset { + _ThriftHiveMetastore_create_table_with_environment_context_args__isset() : tbl(false), environment_context(false) {} + bool tbl :1; + bool environment_context :1; +} _ThriftHiveMetastore_create_table_with_environment_context_args__isset; + +class ThriftHiveMetastore_create_table_with_environment_context_args { + public: + + ThriftHiveMetastore_create_table_with_environment_context_args(const ThriftHiveMetastore_create_table_with_environment_context_args&); + ThriftHiveMetastore_create_table_with_environment_context_args& operator=(const ThriftHiveMetastore_create_table_with_environment_context_args&); + ThriftHiveMetastore_create_table_with_environment_context_args() noexcept; + + virtual ~ThriftHiveMetastore_create_table_with_environment_context_args() noexcept; + Table tbl; + EnvironmentContext environment_context; + + _ThriftHiveMetastore_create_table_with_environment_context_args__isset __isset; + + void __set_tbl(const Table& val); + + void __set_environment_context(const EnvironmentContext& val); + + bool operator == (const ThriftHiveMetastore_create_table_with_environment_context_args & rhs) const; + bool operator != (const ThriftHiveMetastore_create_table_with_environment_context_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_table_with_environment_context_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_create_table_with_environment_context_pargs { + public: + + + virtual ~ThriftHiveMetastore_create_table_with_environment_context_pargs() noexcept; + const Table* tbl; + const EnvironmentContext* environment_context; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_table_with_environment_context_result__isset { + _ThriftHiveMetastore_create_table_with_environment_context_result__isset() : o1(false), o2(false), o3(false), o4(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_create_table_with_environment_context_result__isset; + +class ThriftHiveMetastore_create_table_with_environment_context_result { + public: + + ThriftHiveMetastore_create_table_with_environment_context_result(const ThriftHiveMetastore_create_table_with_environment_context_result&); + ThriftHiveMetastore_create_table_with_environment_context_result& operator=(const ThriftHiveMetastore_create_table_with_environment_context_result&); + ThriftHiveMetastore_create_table_with_environment_context_result() noexcept; + + virtual ~ThriftHiveMetastore_create_table_with_environment_context_result() noexcept; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + NoSuchObjectException o4; + + _ThriftHiveMetastore_create_table_with_environment_context_result__isset __isset; + + void __set_o1(const AlreadyExistsException& val); + + void __set_o2(const InvalidObjectException& val); + + void __set_o3(const MetaException& val); + + void __set_o4(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_create_table_with_environment_context_result & rhs) const; + bool operator != (const ThriftHiveMetastore_create_table_with_environment_context_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_table_with_environment_context_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_table_with_environment_context_presult__isset { + _ThriftHiveMetastore_create_table_with_environment_context_presult__isset() : o1(false), o2(false), o3(false), o4(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_create_table_with_environment_context_presult__isset; + +class ThriftHiveMetastore_create_table_with_environment_context_presult { + public: + + + virtual ~ThriftHiveMetastore_create_table_with_environment_context_presult() noexcept; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + NoSuchObjectException o4; + + _ThriftHiveMetastore_create_table_with_environment_context_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_create_table_with_constraints_args__isset { + _ThriftHiveMetastore_create_table_with_constraints_args__isset() : tbl(false), primaryKeys(false), foreignKeys(false), uniqueConstraints(false), notNullConstraints(false), defaultConstraints(false), checkConstraints(false) {} + bool tbl :1; + bool primaryKeys :1; + bool foreignKeys :1; + bool uniqueConstraints :1; + bool notNullConstraints :1; + bool defaultConstraints :1; + bool checkConstraints :1; +} _ThriftHiveMetastore_create_table_with_constraints_args__isset; + +class ThriftHiveMetastore_create_table_with_constraints_args { + public: + + ThriftHiveMetastore_create_table_with_constraints_args(const ThriftHiveMetastore_create_table_with_constraints_args&); + ThriftHiveMetastore_create_table_with_constraints_args& operator=(const ThriftHiveMetastore_create_table_with_constraints_args&); + ThriftHiveMetastore_create_table_with_constraints_args() noexcept; + + virtual ~ThriftHiveMetastore_create_table_with_constraints_args() noexcept; + Table tbl; + std::vector primaryKeys; + std::vector foreignKeys; + std::vector uniqueConstraints; + std::vector notNullConstraints; + std::vector defaultConstraints; + std::vector checkConstraints; + + _ThriftHiveMetastore_create_table_with_constraints_args__isset __isset; + + void __set_tbl(const Table& val); + + void __set_primaryKeys(const std::vector & val); + + void __set_foreignKeys(const std::vector & val); + + void __set_uniqueConstraints(const std::vector & val); + + void __set_notNullConstraints(const std::vector & val); + + void __set_defaultConstraints(const std::vector & val); + + void __set_checkConstraints(const std::vector & val); + + bool operator == (const ThriftHiveMetastore_create_table_with_constraints_args & rhs) const; + bool operator != (const ThriftHiveMetastore_create_table_with_constraints_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_table_with_constraints_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_create_table_with_constraints_pargs { + public: + + + virtual ~ThriftHiveMetastore_create_table_with_constraints_pargs() noexcept; + const Table* tbl; + const std::vector * primaryKeys; + const std::vector * foreignKeys; + const std::vector * uniqueConstraints; + const std::vector * notNullConstraints; + const std::vector * defaultConstraints; + const std::vector * checkConstraints; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_table_with_constraints_result__isset { + _ThriftHiveMetastore_create_table_with_constraints_result__isset() : o1(false), o2(false), o3(false), o4(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_create_table_with_constraints_result__isset; + +class ThriftHiveMetastore_create_table_with_constraints_result { + public: + + ThriftHiveMetastore_create_table_with_constraints_result(const ThriftHiveMetastore_create_table_with_constraints_result&); + ThriftHiveMetastore_create_table_with_constraints_result& operator=(const ThriftHiveMetastore_create_table_with_constraints_result&); + ThriftHiveMetastore_create_table_with_constraints_result() noexcept; + + virtual ~ThriftHiveMetastore_create_table_with_constraints_result() noexcept; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + NoSuchObjectException o4; + + _ThriftHiveMetastore_create_table_with_constraints_result__isset __isset; + + void __set_o1(const AlreadyExistsException& val); + + void __set_o2(const InvalidObjectException& val); + + void __set_o3(const MetaException& val); + + void __set_o4(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_create_table_with_constraints_result & rhs) const; + bool operator != (const ThriftHiveMetastore_create_table_with_constraints_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_table_with_constraints_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_table_with_constraints_presult__isset { + _ThriftHiveMetastore_create_table_with_constraints_presult__isset() : o1(false), o2(false), o3(false), o4(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_create_table_with_constraints_presult__isset; + +class ThriftHiveMetastore_create_table_with_constraints_presult { + public: + + + virtual ~ThriftHiveMetastore_create_table_with_constraints_presult() noexcept; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + NoSuchObjectException o4; + + _ThriftHiveMetastore_create_table_with_constraints_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_create_table_req_args__isset { + _ThriftHiveMetastore_create_table_req_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_create_table_req_args__isset; + +class ThriftHiveMetastore_create_table_req_args { + public: + + ThriftHiveMetastore_create_table_req_args(const ThriftHiveMetastore_create_table_req_args&); + ThriftHiveMetastore_create_table_req_args& operator=(const ThriftHiveMetastore_create_table_req_args&); + ThriftHiveMetastore_create_table_req_args() noexcept; + + virtual ~ThriftHiveMetastore_create_table_req_args() noexcept; + CreateTableRequest request; + + _ThriftHiveMetastore_create_table_req_args__isset __isset; + + void __set_request(const CreateTableRequest& val); + + bool operator == (const ThriftHiveMetastore_create_table_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_create_table_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_table_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_create_table_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_create_table_req_pargs() noexcept; + const CreateTableRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_table_req_result__isset { + _ThriftHiveMetastore_create_table_req_result__isset() : o1(false), o2(false), o3(false), o4(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_create_table_req_result__isset; + +class ThriftHiveMetastore_create_table_req_result { + public: + + ThriftHiveMetastore_create_table_req_result(const ThriftHiveMetastore_create_table_req_result&); + ThriftHiveMetastore_create_table_req_result& operator=(const ThriftHiveMetastore_create_table_req_result&); + ThriftHiveMetastore_create_table_req_result() noexcept; + + virtual ~ThriftHiveMetastore_create_table_req_result() noexcept; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + NoSuchObjectException o4; + + _ThriftHiveMetastore_create_table_req_result__isset __isset; + + void __set_o1(const AlreadyExistsException& val); + + void __set_o2(const InvalidObjectException& val); + + void __set_o3(const MetaException& val); + + void __set_o4(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_create_table_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_create_table_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_table_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_table_req_presult__isset { + _ThriftHiveMetastore_create_table_req_presult__isset() : o1(false), o2(false), o3(false), o4(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_create_table_req_presult__isset; + +class ThriftHiveMetastore_create_table_req_presult { + public: + + + virtual ~ThriftHiveMetastore_create_table_req_presult() noexcept; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + NoSuchObjectException o4; + + _ThriftHiveMetastore_create_table_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_constraint_args__isset { + _ThriftHiveMetastore_drop_constraint_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_drop_constraint_args__isset; + +class ThriftHiveMetastore_drop_constraint_args { + public: + + ThriftHiveMetastore_drop_constraint_args(const ThriftHiveMetastore_drop_constraint_args&); + ThriftHiveMetastore_drop_constraint_args& operator=(const ThriftHiveMetastore_drop_constraint_args&); + ThriftHiveMetastore_drop_constraint_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_constraint_args() noexcept; + DropConstraintRequest req; + + _ThriftHiveMetastore_drop_constraint_args__isset __isset; + + void __set_req(const DropConstraintRequest& val); + + bool operator == (const ThriftHiveMetastore_drop_constraint_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_constraint_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_constraint_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_constraint_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_constraint_pargs() noexcept; + const DropConstraintRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_constraint_result__isset { + _ThriftHiveMetastore_drop_constraint_result__isset() : o1(false), o3(false) {} + bool o1 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_constraint_result__isset; + +class ThriftHiveMetastore_drop_constraint_result { + public: + + ThriftHiveMetastore_drop_constraint_result(const ThriftHiveMetastore_drop_constraint_result&); + ThriftHiveMetastore_drop_constraint_result& operator=(const ThriftHiveMetastore_drop_constraint_result&); + ThriftHiveMetastore_drop_constraint_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_constraint_result() noexcept; + NoSuchObjectException o1; + MetaException o3; + + _ThriftHiveMetastore_drop_constraint_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_constraint_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_constraint_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_constraint_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_constraint_presult__isset { + _ThriftHiveMetastore_drop_constraint_presult__isset() : o1(false), o3(false) {} + bool o1 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_constraint_presult__isset; + +class ThriftHiveMetastore_drop_constraint_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_constraint_presult() noexcept; + NoSuchObjectException o1; + MetaException o3; + + _ThriftHiveMetastore_drop_constraint_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_add_primary_key_args__isset { + _ThriftHiveMetastore_add_primary_key_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_add_primary_key_args__isset; + +class ThriftHiveMetastore_add_primary_key_args { + public: + + ThriftHiveMetastore_add_primary_key_args(const ThriftHiveMetastore_add_primary_key_args&); + ThriftHiveMetastore_add_primary_key_args& operator=(const ThriftHiveMetastore_add_primary_key_args&); + ThriftHiveMetastore_add_primary_key_args() noexcept; + + virtual ~ThriftHiveMetastore_add_primary_key_args() noexcept; + AddPrimaryKeyRequest req; + + _ThriftHiveMetastore_add_primary_key_args__isset __isset; + + void __set_req(const AddPrimaryKeyRequest& val); + + bool operator == (const ThriftHiveMetastore_add_primary_key_args & rhs) const; + bool operator != (const ThriftHiveMetastore_add_primary_key_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_primary_key_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_primary_key_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_primary_key_pargs() noexcept; + const AddPrimaryKeyRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_primary_key_result__isset { + _ThriftHiveMetastore_add_primary_key_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_add_primary_key_result__isset; + +class ThriftHiveMetastore_add_primary_key_result { + public: + + ThriftHiveMetastore_add_primary_key_result(const ThriftHiveMetastore_add_primary_key_result&); + ThriftHiveMetastore_add_primary_key_result& operator=(const ThriftHiveMetastore_add_primary_key_result&); + ThriftHiveMetastore_add_primary_key_result() noexcept; + + virtual ~ThriftHiveMetastore_add_primary_key_result() noexcept; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_add_primary_key_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_add_primary_key_result & rhs) const; + bool operator != (const ThriftHiveMetastore_add_primary_key_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_primary_key_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_primary_key_presult__isset { + _ThriftHiveMetastore_add_primary_key_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_add_primary_key_presult__isset; + +class ThriftHiveMetastore_add_primary_key_presult { + public: + + + virtual ~ThriftHiveMetastore_add_primary_key_presult() noexcept; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_add_primary_key_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_add_foreign_key_args__isset { + _ThriftHiveMetastore_add_foreign_key_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_add_foreign_key_args__isset; + +class ThriftHiveMetastore_add_foreign_key_args { + public: + + ThriftHiveMetastore_add_foreign_key_args(const ThriftHiveMetastore_add_foreign_key_args&); + ThriftHiveMetastore_add_foreign_key_args& operator=(const ThriftHiveMetastore_add_foreign_key_args&); + ThriftHiveMetastore_add_foreign_key_args() noexcept; + + virtual ~ThriftHiveMetastore_add_foreign_key_args() noexcept; + AddForeignKeyRequest req; + + _ThriftHiveMetastore_add_foreign_key_args__isset __isset; + + void __set_req(const AddForeignKeyRequest& val); + + bool operator == (const ThriftHiveMetastore_add_foreign_key_args & rhs) const; + bool operator != (const ThriftHiveMetastore_add_foreign_key_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_foreign_key_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_foreign_key_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_foreign_key_pargs() noexcept; + const AddForeignKeyRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_foreign_key_result__isset { + _ThriftHiveMetastore_add_foreign_key_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_add_foreign_key_result__isset; + +class ThriftHiveMetastore_add_foreign_key_result { + public: + + ThriftHiveMetastore_add_foreign_key_result(const ThriftHiveMetastore_add_foreign_key_result&); + ThriftHiveMetastore_add_foreign_key_result& operator=(const ThriftHiveMetastore_add_foreign_key_result&); + ThriftHiveMetastore_add_foreign_key_result() noexcept; + + virtual ~ThriftHiveMetastore_add_foreign_key_result() noexcept; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_add_foreign_key_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_add_foreign_key_result & rhs) const; + bool operator != (const ThriftHiveMetastore_add_foreign_key_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_foreign_key_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_foreign_key_presult__isset { + _ThriftHiveMetastore_add_foreign_key_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_add_foreign_key_presult__isset; + +class ThriftHiveMetastore_add_foreign_key_presult { + public: + + + virtual ~ThriftHiveMetastore_add_foreign_key_presult() noexcept; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_add_foreign_key_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_add_unique_constraint_args__isset { + _ThriftHiveMetastore_add_unique_constraint_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_add_unique_constraint_args__isset; + +class ThriftHiveMetastore_add_unique_constraint_args { + public: + + ThriftHiveMetastore_add_unique_constraint_args(const ThriftHiveMetastore_add_unique_constraint_args&); + ThriftHiveMetastore_add_unique_constraint_args& operator=(const ThriftHiveMetastore_add_unique_constraint_args&); + ThriftHiveMetastore_add_unique_constraint_args() noexcept; + + virtual ~ThriftHiveMetastore_add_unique_constraint_args() noexcept; + AddUniqueConstraintRequest req; + + _ThriftHiveMetastore_add_unique_constraint_args__isset __isset; + + void __set_req(const AddUniqueConstraintRequest& val); + + bool operator == (const ThriftHiveMetastore_add_unique_constraint_args & rhs) const; + bool operator != (const ThriftHiveMetastore_add_unique_constraint_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_unique_constraint_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_unique_constraint_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_unique_constraint_pargs() noexcept; + const AddUniqueConstraintRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_unique_constraint_result__isset { + _ThriftHiveMetastore_add_unique_constraint_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_add_unique_constraint_result__isset; + +class ThriftHiveMetastore_add_unique_constraint_result { + public: + + ThriftHiveMetastore_add_unique_constraint_result(const ThriftHiveMetastore_add_unique_constraint_result&); + ThriftHiveMetastore_add_unique_constraint_result& operator=(const ThriftHiveMetastore_add_unique_constraint_result&); + ThriftHiveMetastore_add_unique_constraint_result() noexcept; + + virtual ~ThriftHiveMetastore_add_unique_constraint_result() noexcept; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_add_unique_constraint_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_add_unique_constraint_result & rhs) const; + bool operator != (const ThriftHiveMetastore_add_unique_constraint_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_unique_constraint_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_unique_constraint_presult__isset { + _ThriftHiveMetastore_add_unique_constraint_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_add_unique_constraint_presult__isset; + +class ThriftHiveMetastore_add_unique_constraint_presult { + public: + + + virtual ~ThriftHiveMetastore_add_unique_constraint_presult() noexcept; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_add_unique_constraint_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_add_not_null_constraint_args__isset { + _ThriftHiveMetastore_add_not_null_constraint_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_add_not_null_constraint_args__isset; + +class ThriftHiveMetastore_add_not_null_constraint_args { + public: + + ThriftHiveMetastore_add_not_null_constraint_args(const ThriftHiveMetastore_add_not_null_constraint_args&); + ThriftHiveMetastore_add_not_null_constraint_args& operator=(const ThriftHiveMetastore_add_not_null_constraint_args&); + ThriftHiveMetastore_add_not_null_constraint_args() noexcept; + + virtual ~ThriftHiveMetastore_add_not_null_constraint_args() noexcept; + AddNotNullConstraintRequest req; + + _ThriftHiveMetastore_add_not_null_constraint_args__isset __isset; + + void __set_req(const AddNotNullConstraintRequest& val); + + bool operator == (const ThriftHiveMetastore_add_not_null_constraint_args & rhs) const; + bool operator != (const ThriftHiveMetastore_add_not_null_constraint_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_not_null_constraint_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_not_null_constraint_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_not_null_constraint_pargs() noexcept; + const AddNotNullConstraintRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_not_null_constraint_result__isset { + _ThriftHiveMetastore_add_not_null_constraint_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_add_not_null_constraint_result__isset; + +class ThriftHiveMetastore_add_not_null_constraint_result { + public: + + ThriftHiveMetastore_add_not_null_constraint_result(const ThriftHiveMetastore_add_not_null_constraint_result&); + ThriftHiveMetastore_add_not_null_constraint_result& operator=(const ThriftHiveMetastore_add_not_null_constraint_result&); + ThriftHiveMetastore_add_not_null_constraint_result() noexcept; + + virtual ~ThriftHiveMetastore_add_not_null_constraint_result() noexcept; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_add_not_null_constraint_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_add_not_null_constraint_result & rhs) const; + bool operator != (const ThriftHiveMetastore_add_not_null_constraint_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_not_null_constraint_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_not_null_constraint_presult__isset { + _ThriftHiveMetastore_add_not_null_constraint_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_add_not_null_constraint_presult__isset; + +class ThriftHiveMetastore_add_not_null_constraint_presult { + public: + + + virtual ~ThriftHiveMetastore_add_not_null_constraint_presult() noexcept; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_add_not_null_constraint_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_add_default_constraint_args__isset { + _ThriftHiveMetastore_add_default_constraint_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_add_default_constraint_args__isset; + +class ThriftHiveMetastore_add_default_constraint_args { + public: + + ThriftHiveMetastore_add_default_constraint_args(const ThriftHiveMetastore_add_default_constraint_args&); + ThriftHiveMetastore_add_default_constraint_args& operator=(const ThriftHiveMetastore_add_default_constraint_args&); + ThriftHiveMetastore_add_default_constraint_args() noexcept; + + virtual ~ThriftHiveMetastore_add_default_constraint_args() noexcept; + AddDefaultConstraintRequest req; + + _ThriftHiveMetastore_add_default_constraint_args__isset __isset; + + void __set_req(const AddDefaultConstraintRequest& val); + + bool operator == (const ThriftHiveMetastore_add_default_constraint_args & rhs) const; + bool operator != (const ThriftHiveMetastore_add_default_constraint_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_default_constraint_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_default_constraint_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_default_constraint_pargs() noexcept; + const AddDefaultConstraintRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_default_constraint_result__isset { + _ThriftHiveMetastore_add_default_constraint_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_add_default_constraint_result__isset; + +class ThriftHiveMetastore_add_default_constraint_result { + public: + + ThriftHiveMetastore_add_default_constraint_result(const ThriftHiveMetastore_add_default_constraint_result&); + ThriftHiveMetastore_add_default_constraint_result& operator=(const ThriftHiveMetastore_add_default_constraint_result&); + ThriftHiveMetastore_add_default_constraint_result() noexcept; + + virtual ~ThriftHiveMetastore_add_default_constraint_result() noexcept; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_add_default_constraint_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_add_default_constraint_result & rhs) const; + bool operator != (const ThriftHiveMetastore_add_default_constraint_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_default_constraint_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_default_constraint_presult__isset { + _ThriftHiveMetastore_add_default_constraint_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_add_default_constraint_presult__isset; + +class ThriftHiveMetastore_add_default_constraint_presult { + public: + + + virtual ~ThriftHiveMetastore_add_default_constraint_presult() noexcept; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_add_default_constraint_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_add_check_constraint_args__isset { + _ThriftHiveMetastore_add_check_constraint_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_add_check_constraint_args__isset; + +class ThriftHiveMetastore_add_check_constraint_args { + public: + + ThriftHiveMetastore_add_check_constraint_args(const ThriftHiveMetastore_add_check_constraint_args&); + ThriftHiveMetastore_add_check_constraint_args& operator=(const ThriftHiveMetastore_add_check_constraint_args&); + ThriftHiveMetastore_add_check_constraint_args() noexcept; + + virtual ~ThriftHiveMetastore_add_check_constraint_args() noexcept; + AddCheckConstraintRequest req; + + _ThriftHiveMetastore_add_check_constraint_args__isset __isset; + + void __set_req(const AddCheckConstraintRequest& val); + + bool operator == (const ThriftHiveMetastore_add_check_constraint_args & rhs) const; + bool operator != (const ThriftHiveMetastore_add_check_constraint_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_check_constraint_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_check_constraint_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_check_constraint_pargs() noexcept; + const AddCheckConstraintRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_check_constraint_result__isset { + _ThriftHiveMetastore_add_check_constraint_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_add_check_constraint_result__isset; + +class ThriftHiveMetastore_add_check_constraint_result { + public: + + ThriftHiveMetastore_add_check_constraint_result(const ThriftHiveMetastore_add_check_constraint_result&); + ThriftHiveMetastore_add_check_constraint_result& operator=(const ThriftHiveMetastore_add_check_constraint_result&); + ThriftHiveMetastore_add_check_constraint_result() noexcept; + + virtual ~ThriftHiveMetastore_add_check_constraint_result() noexcept; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_add_check_constraint_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_add_check_constraint_result & rhs) const; + bool operator != (const ThriftHiveMetastore_add_check_constraint_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_check_constraint_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_check_constraint_presult__isset { + _ThriftHiveMetastore_add_check_constraint_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_add_check_constraint_presult__isset; + +class ThriftHiveMetastore_add_check_constraint_presult { + public: + + + virtual ~ThriftHiveMetastore_add_check_constraint_presult() noexcept; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_add_check_constraint_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_translate_table_dryrun_args__isset { + _ThriftHiveMetastore_translate_table_dryrun_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_translate_table_dryrun_args__isset; + +class ThriftHiveMetastore_translate_table_dryrun_args { + public: + + ThriftHiveMetastore_translate_table_dryrun_args(const ThriftHiveMetastore_translate_table_dryrun_args&); + ThriftHiveMetastore_translate_table_dryrun_args& operator=(const ThriftHiveMetastore_translate_table_dryrun_args&); + ThriftHiveMetastore_translate_table_dryrun_args() noexcept; + + virtual ~ThriftHiveMetastore_translate_table_dryrun_args() noexcept; + CreateTableRequest request; + + _ThriftHiveMetastore_translate_table_dryrun_args__isset __isset; + + void __set_request(const CreateTableRequest& val); + + bool operator == (const ThriftHiveMetastore_translate_table_dryrun_args & rhs) const; + bool operator != (const ThriftHiveMetastore_translate_table_dryrun_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_translate_table_dryrun_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_translate_table_dryrun_pargs { + public: + + + virtual ~ThriftHiveMetastore_translate_table_dryrun_pargs() noexcept; + const CreateTableRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_translate_table_dryrun_result__isset { + _ThriftHiveMetastore_translate_table_dryrun_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_translate_table_dryrun_result__isset; + +class ThriftHiveMetastore_translate_table_dryrun_result { + public: + + ThriftHiveMetastore_translate_table_dryrun_result(const ThriftHiveMetastore_translate_table_dryrun_result&); + ThriftHiveMetastore_translate_table_dryrun_result& operator=(const ThriftHiveMetastore_translate_table_dryrun_result&); + ThriftHiveMetastore_translate_table_dryrun_result() noexcept; + + virtual ~ThriftHiveMetastore_translate_table_dryrun_result() noexcept; + Table success; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + NoSuchObjectException o4; + + _ThriftHiveMetastore_translate_table_dryrun_result__isset __isset; + + void __set_success(const Table& val); + + void __set_o1(const AlreadyExistsException& val); + + void __set_o2(const InvalidObjectException& val); + + void __set_o3(const MetaException& val); + + void __set_o4(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_translate_table_dryrun_result & rhs) const; + bool operator != (const ThriftHiveMetastore_translate_table_dryrun_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_translate_table_dryrun_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_translate_table_dryrun_presult__isset { + _ThriftHiveMetastore_translate_table_dryrun_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_translate_table_dryrun_presult__isset; + +class ThriftHiveMetastore_translate_table_dryrun_presult { + public: + + + virtual ~ThriftHiveMetastore_translate_table_dryrun_presult() noexcept; + Table* success; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + NoSuchObjectException o4; + + _ThriftHiveMetastore_translate_table_dryrun_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_table_args__isset { + _ThriftHiveMetastore_drop_table_args__isset() : dbname(false), name(false), deleteData(false) {} + bool dbname :1; + bool name :1; + bool deleteData :1; +} _ThriftHiveMetastore_drop_table_args__isset; + +class ThriftHiveMetastore_drop_table_args { + public: + + ThriftHiveMetastore_drop_table_args(const ThriftHiveMetastore_drop_table_args&); + ThriftHiveMetastore_drop_table_args& operator=(const ThriftHiveMetastore_drop_table_args&); + ThriftHiveMetastore_drop_table_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_table_args() noexcept; + std::string dbname; + std::string name; + bool deleteData; + + _ThriftHiveMetastore_drop_table_args__isset __isset; + + void __set_dbname(const std::string& val); + + void __set_name(const std::string& val); + + void __set_deleteData(const bool val); + + bool operator == (const ThriftHiveMetastore_drop_table_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_table_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_table_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_table_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_table_pargs() noexcept; + const std::string* dbname; + const std::string* name; + const bool* deleteData; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_table_result__isset { + _ThriftHiveMetastore_drop_table_result__isset() : o1(false), o3(false) {} + bool o1 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_table_result__isset; + +class ThriftHiveMetastore_drop_table_result { + public: + + ThriftHiveMetastore_drop_table_result(const ThriftHiveMetastore_drop_table_result&); + ThriftHiveMetastore_drop_table_result& operator=(const ThriftHiveMetastore_drop_table_result&); + ThriftHiveMetastore_drop_table_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_table_result() noexcept; + NoSuchObjectException o1; + MetaException o3; + + _ThriftHiveMetastore_drop_table_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_table_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_table_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_table_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_table_presult__isset { + _ThriftHiveMetastore_drop_table_presult__isset() : o1(false), o3(false) {} + bool o1 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_table_presult__isset; + +class ThriftHiveMetastore_drop_table_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_table_presult() noexcept; + NoSuchObjectException o1; + MetaException o3; + + _ThriftHiveMetastore_drop_table_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_table_with_environment_context_args__isset { + _ThriftHiveMetastore_drop_table_with_environment_context_args__isset() : dbname(false), name(false), deleteData(false), environment_context(false) {} + bool dbname :1; + bool name :1; + bool deleteData :1; + bool environment_context :1; +} _ThriftHiveMetastore_drop_table_with_environment_context_args__isset; + +class ThriftHiveMetastore_drop_table_with_environment_context_args { + public: + + ThriftHiveMetastore_drop_table_with_environment_context_args(const ThriftHiveMetastore_drop_table_with_environment_context_args&); + ThriftHiveMetastore_drop_table_with_environment_context_args& operator=(const ThriftHiveMetastore_drop_table_with_environment_context_args&); + ThriftHiveMetastore_drop_table_with_environment_context_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_table_with_environment_context_args() noexcept; + std::string dbname; + std::string name; + bool deleteData; + EnvironmentContext environment_context; + + _ThriftHiveMetastore_drop_table_with_environment_context_args__isset __isset; + + void __set_dbname(const std::string& val); + + void __set_name(const std::string& val); + + void __set_deleteData(const bool val); + + void __set_environment_context(const EnvironmentContext& val); + + bool operator == (const ThriftHiveMetastore_drop_table_with_environment_context_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_table_with_environment_context_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_table_with_environment_context_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_table_with_environment_context_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_table_with_environment_context_pargs() noexcept; + const std::string* dbname; + const std::string* name; + const bool* deleteData; + const EnvironmentContext* environment_context; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_table_with_environment_context_result__isset { + _ThriftHiveMetastore_drop_table_with_environment_context_result__isset() : o1(false), o3(false) {} + bool o1 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_table_with_environment_context_result__isset; + +class ThriftHiveMetastore_drop_table_with_environment_context_result { + public: + + ThriftHiveMetastore_drop_table_with_environment_context_result(const ThriftHiveMetastore_drop_table_with_environment_context_result&); + ThriftHiveMetastore_drop_table_with_environment_context_result& operator=(const ThriftHiveMetastore_drop_table_with_environment_context_result&); + ThriftHiveMetastore_drop_table_with_environment_context_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_table_with_environment_context_result() noexcept; + NoSuchObjectException o1; + MetaException o3; + + _ThriftHiveMetastore_drop_table_with_environment_context_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_table_with_environment_context_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_table_with_environment_context_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_table_with_environment_context_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_table_with_environment_context_presult__isset { + _ThriftHiveMetastore_drop_table_with_environment_context_presult__isset() : o1(false), o3(false) {} + bool o1 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_table_with_environment_context_presult__isset; + +class ThriftHiveMetastore_drop_table_with_environment_context_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_table_with_environment_context_presult() noexcept; + NoSuchObjectException o1; + MetaException o3; + + _ThriftHiveMetastore_drop_table_with_environment_context_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_table_req_args__isset { + _ThriftHiveMetastore_drop_table_req_args__isset() : dropTableReq(false) {} + bool dropTableReq :1; +} _ThriftHiveMetastore_drop_table_req_args__isset; + +class ThriftHiveMetastore_drop_table_req_args { + public: + + ThriftHiveMetastore_drop_table_req_args(const ThriftHiveMetastore_drop_table_req_args&); + ThriftHiveMetastore_drop_table_req_args& operator=(const ThriftHiveMetastore_drop_table_req_args&); + ThriftHiveMetastore_drop_table_req_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_table_req_args() noexcept; + DropTableRequest dropTableReq; + + _ThriftHiveMetastore_drop_table_req_args__isset __isset; + + void __set_dropTableReq(const DropTableRequest& val); + + bool operator == (const ThriftHiveMetastore_drop_table_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_table_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_table_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_table_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_table_req_pargs() noexcept; + const DropTableRequest* dropTableReq; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_table_req_result__isset { + _ThriftHiveMetastore_drop_table_req_result__isset() : o1(false), o3(false) {} + bool o1 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_table_req_result__isset; + +class ThriftHiveMetastore_drop_table_req_result { + public: + + ThriftHiveMetastore_drop_table_req_result(const ThriftHiveMetastore_drop_table_req_result&); + ThriftHiveMetastore_drop_table_req_result& operator=(const ThriftHiveMetastore_drop_table_req_result&); + ThriftHiveMetastore_drop_table_req_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_table_req_result() noexcept; + NoSuchObjectException o1; + MetaException o3; + + _ThriftHiveMetastore_drop_table_req_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_table_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_table_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_table_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_table_req_presult__isset { + _ThriftHiveMetastore_drop_table_req_presult__isset() : o1(false), o3(false) {} + bool o1 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_table_req_presult__isset; + +class ThriftHiveMetastore_drop_table_req_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_table_req_presult() noexcept; + NoSuchObjectException o1; + MetaException o3; + + _ThriftHiveMetastore_drop_table_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_truncate_table_args__isset { + _ThriftHiveMetastore_truncate_table_args__isset() : dbName(false), tableName(false), partNames(false) {} + bool dbName :1; + bool tableName :1; + bool partNames :1; +} _ThriftHiveMetastore_truncate_table_args__isset; + +class ThriftHiveMetastore_truncate_table_args { + public: + + ThriftHiveMetastore_truncate_table_args(const ThriftHiveMetastore_truncate_table_args&); + ThriftHiveMetastore_truncate_table_args& operator=(const ThriftHiveMetastore_truncate_table_args&); + ThriftHiveMetastore_truncate_table_args() noexcept; + + virtual ~ThriftHiveMetastore_truncate_table_args() noexcept; + std::string dbName; + std::string tableName; + std::vector partNames; + + _ThriftHiveMetastore_truncate_table_args__isset __isset; + + void __set_dbName(const std::string& val); + + void __set_tableName(const std::string& val); + + void __set_partNames(const std::vector & val); + + bool operator == (const ThriftHiveMetastore_truncate_table_args & rhs) const; + bool operator != (const ThriftHiveMetastore_truncate_table_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_truncate_table_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_truncate_table_pargs { + public: + + + virtual ~ThriftHiveMetastore_truncate_table_pargs() noexcept; + const std::string* dbName; + const std::string* tableName; + const std::vector * partNames; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_truncate_table_result__isset { + _ThriftHiveMetastore_truncate_table_result__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_truncate_table_result__isset; + +class ThriftHiveMetastore_truncate_table_result { + public: + + ThriftHiveMetastore_truncate_table_result(const ThriftHiveMetastore_truncate_table_result&); + ThriftHiveMetastore_truncate_table_result& operator=(const ThriftHiveMetastore_truncate_table_result&); + ThriftHiveMetastore_truncate_table_result() noexcept; + + virtual ~ThriftHiveMetastore_truncate_table_result() noexcept; + MetaException o1; + + _ThriftHiveMetastore_truncate_table_result__isset __isset; + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_truncate_table_result & rhs) const; + bool operator != (const ThriftHiveMetastore_truncate_table_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_truncate_table_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_truncate_table_presult__isset { + _ThriftHiveMetastore_truncate_table_presult__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_truncate_table_presult__isset; + +class ThriftHiveMetastore_truncate_table_presult { + public: + + + virtual ~ThriftHiveMetastore_truncate_table_presult() noexcept; + MetaException o1; + + _ThriftHiveMetastore_truncate_table_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_truncate_table_req_args__isset { + _ThriftHiveMetastore_truncate_table_req_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_truncate_table_req_args__isset; + +class ThriftHiveMetastore_truncate_table_req_args { + public: + + ThriftHiveMetastore_truncate_table_req_args(const ThriftHiveMetastore_truncate_table_req_args&); + ThriftHiveMetastore_truncate_table_req_args& operator=(const ThriftHiveMetastore_truncate_table_req_args&); + ThriftHiveMetastore_truncate_table_req_args() noexcept; + + virtual ~ThriftHiveMetastore_truncate_table_req_args() noexcept; + TruncateTableRequest req; + + _ThriftHiveMetastore_truncate_table_req_args__isset __isset; + + void __set_req(const TruncateTableRequest& val); + + bool operator == (const ThriftHiveMetastore_truncate_table_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_truncate_table_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_truncate_table_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_truncate_table_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_truncate_table_req_pargs() noexcept; + const TruncateTableRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_truncate_table_req_result__isset { + _ThriftHiveMetastore_truncate_table_req_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_truncate_table_req_result__isset; + +class ThriftHiveMetastore_truncate_table_req_result { + public: + + ThriftHiveMetastore_truncate_table_req_result(const ThriftHiveMetastore_truncate_table_req_result&); + ThriftHiveMetastore_truncate_table_req_result& operator=(const ThriftHiveMetastore_truncate_table_req_result&); + ThriftHiveMetastore_truncate_table_req_result() noexcept; + + virtual ~ThriftHiveMetastore_truncate_table_req_result() noexcept; + TruncateTableResponse success; + MetaException o1; + + _ThriftHiveMetastore_truncate_table_req_result__isset __isset; + + void __set_success(const TruncateTableResponse& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_truncate_table_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_truncate_table_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_truncate_table_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_truncate_table_req_presult__isset { + _ThriftHiveMetastore_truncate_table_req_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_truncate_table_req_presult__isset; + +class ThriftHiveMetastore_truncate_table_req_presult { + public: + + + virtual ~ThriftHiveMetastore_truncate_table_req_presult() noexcept; + TruncateTableResponse* success; + MetaException o1; + + _ThriftHiveMetastore_truncate_table_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_tables_args__isset { + _ThriftHiveMetastore_get_tables_args__isset() : db_name(false), pattern(false) {} + bool db_name :1; + bool pattern :1; +} _ThriftHiveMetastore_get_tables_args__isset; + +class ThriftHiveMetastore_get_tables_args { + public: + + ThriftHiveMetastore_get_tables_args(const ThriftHiveMetastore_get_tables_args&); + ThriftHiveMetastore_get_tables_args& operator=(const ThriftHiveMetastore_get_tables_args&); + ThriftHiveMetastore_get_tables_args() noexcept; + + virtual ~ThriftHiveMetastore_get_tables_args() noexcept; + std::string db_name; + std::string pattern; + + _ThriftHiveMetastore_get_tables_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_pattern(const std::string& val); + + bool operator == (const ThriftHiveMetastore_get_tables_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_tables_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_tables_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_tables_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_tables_pargs() noexcept; + const std::string* db_name; + const std::string* pattern; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_tables_result__isset { + _ThriftHiveMetastore_get_tables_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_tables_result__isset; + +class ThriftHiveMetastore_get_tables_result { + public: + + ThriftHiveMetastore_get_tables_result(const ThriftHiveMetastore_get_tables_result&); + ThriftHiveMetastore_get_tables_result& operator=(const ThriftHiveMetastore_get_tables_result&); + ThriftHiveMetastore_get_tables_result() noexcept; + + virtual ~ThriftHiveMetastore_get_tables_result() noexcept; + std::vector success; + MetaException o1; + + _ThriftHiveMetastore_get_tables_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_tables_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_tables_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_tables_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_tables_presult__isset { + _ThriftHiveMetastore_get_tables_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_tables_presult__isset; + +class ThriftHiveMetastore_get_tables_presult { + public: + + + virtual ~ThriftHiveMetastore_get_tables_presult() noexcept; + std::vector * success; + MetaException o1; + + _ThriftHiveMetastore_get_tables_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_tables_by_type_args__isset { + _ThriftHiveMetastore_get_tables_by_type_args__isset() : db_name(false), pattern(false), tableType(false) {} + bool db_name :1; + bool pattern :1; + bool tableType :1; +} _ThriftHiveMetastore_get_tables_by_type_args__isset; + +class ThriftHiveMetastore_get_tables_by_type_args { + public: + + ThriftHiveMetastore_get_tables_by_type_args(const ThriftHiveMetastore_get_tables_by_type_args&); + ThriftHiveMetastore_get_tables_by_type_args& operator=(const ThriftHiveMetastore_get_tables_by_type_args&); + ThriftHiveMetastore_get_tables_by_type_args() noexcept; + + virtual ~ThriftHiveMetastore_get_tables_by_type_args() noexcept; + std::string db_name; + std::string pattern; + std::string tableType; + + _ThriftHiveMetastore_get_tables_by_type_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_pattern(const std::string& val); + + void __set_tableType(const std::string& val); + + bool operator == (const ThriftHiveMetastore_get_tables_by_type_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_tables_by_type_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_tables_by_type_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_tables_by_type_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_tables_by_type_pargs() noexcept; + const std::string* db_name; + const std::string* pattern; + const std::string* tableType; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_tables_by_type_result__isset { + _ThriftHiveMetastore_get_tables_by_type_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_tables_by_type_result__isset; + +class ThriftHiveMetastore_get_tables_by_type_result { + public: + + ThriftHiveMetastore_get_tables_by_type_result(const ThriftHiveMetastore_get_tables_by_type_result&); + ThriftHiveMetastore_get_tables_by_type_result& operator=(const ThriftHiveMetastore_get_tables_by_type_result&); + ThriftHiveMetastore_get_tables_by_type_result() noexcept; + + virtual ~ThriftHiveMetastore_get_tables_by_type_result() noexcept; + std::vector success; + MetaException o1; + + _ThriftHiveMetastore_get_tables_by_type_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_tables_by_type_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_tables_by_type_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_tables_by_type_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_tables_by_type_presult__isset { + _ThriftHiveMetastore_get_tables_by_type_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_tables_by_type_presult__isset; + +class ThriftHiveMetastore_get_tables_by_type_presult { + public: + + + virtual ~ThriftHiveMetastore_get_tables_by_type_presult() noexcept; + std::vector * success; + MetaException o1; + + _ThriftHiveMetastore_get_tables_by_type_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + + +class ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_args { + public: + + ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_args(const ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_args&) noexcept; + ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_args& operator=(const ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_args&) noexcept; + ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_args() noexcept; + + virtual ~ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_args() noexcept; + + bool operator == (const ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_args & /* rhs */) const; + bool operator != (const ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_pargs() noexcept; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_result__isset { + _ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_result__isset; + +class ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_result { + public: + + ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_result(const ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_result&); + ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_result& operator=(const ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_result&); + ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_result() noexcept; + + virtual ~ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_result() noexcept; + std::vector
success; + MetaException o1; + + _ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_result__isset __isset; + + void __set_success(const std::vector
& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_presult__isset { + _ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_presult__isset; + +class ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_presult { + public: + + + virtual ~ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_presult() noexcept; + std::vector
* success; + MetaException o1; + + _ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_materialized_views_for_rewriting_args__isset { + _ThriftHiveMetastore_get_materialized_views_for_rewriting_args__isset() : db_name(false) {} + bool db_name :1; +} _ThriftHiveMetastore_get_materialized_views_for_rewriting_args__isset; + +class ThriftHiveMetastore_get_materialized_views_for_rewriting_args { + public: + + ThriftHiveMetastore_get_materialized_views_for_rewriting_args(const ThriftHiveMetastore_get_materialized_views_for_rewriting_args&); + ThriftHiveMetastore_get_materialized_views_for_rewriting_args& operator=(const ThriftHiveMetastore_get_materialized_views_for_rewriting_args&); + ThriftHiveMetastore_get_materialized_views_for_rewriting_args() noexcept; + + virtual ~ThriftHiveMetastore_get_materialized_views_for_rewriting_args() noexcept; + std::string db_name; + + _ThriftHiveMetastore_get_materialized_views_for_rewriting_args__isset __isset; + + void __set_db_name(const std::string& val); + + bool operator == (const ThriftHiveMetastore_get_materialized_views_for_rewriting_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_materialized_views_for_rewriting_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_materialized_views_for_rewriting_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_materialized_views_for_rewriting_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_materialized_views_for_rewriting_pargs() noexcept; + const std::string* db_name; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_materialized_views_for_rewriting_result__isset { + _ThriftHiveMetastore_get_materialized_views_for_rewriting_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_materialized_views_for_rewriting_result__isset; + +class ThriftHiveMetastore_get_materialized_views_for_rewriting_result { + public: + + ThriftHiveMetastore_get_materialized_views_for_rewriting_result(const ThriftHiveMetastore_get_materialized_views_for_rewriting_result&); + ThriftHiveMetastore_get_materialized_views_for_rewriting_result& operator=(const ThriftHiveMetastore_get_materialized_views_for_rewriting_result&); + ThriftHiveMetastore_get_materialized_views_for_rewriting_result() noexcept; + + virtual ~ThriftHiveMetastore_get_materialized_views_for_rewriting_result() noexcept; + std::vector success; + MetaException o1; + + _ThriftHiveMetastore_get_materialized_views_for_rewriting_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_materialized_views_for_rewriting_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_materialized_views_for_rewriting_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_materialized_views_for_rewriting_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_materialized_views_for_rewriting_presult__isset { + _ThriftHiveMetastore_get_materialized_views_for_rewriting_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_materialized_views_for_rewriting_presult__isset; + +class ThriftHiveMetastore_get_materialized_views_for_rewriting_presult { + public: + + + virtual ~ThriftHiveMetastore_get_materialized_views_for_rewriting_presult() noexcept; + std::vector * success; + MetaException o1; + + _ThriftHiveMetastore_get_materialized_views_for_rewriting_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_table_meta_args__isset { + _ThriftHiveMetastore_get_table_meta_args__isset() : db_patterns(false), tbl_patterns(false), tbl_types(false) {} + bool db_patterns :1; + bool tbl_patterns :1; + bool tbl_types :1; +} _ThriftHiveMetastore_get_table_meta_args__isset; + +class ThriftHiveMetastore_get_table_meta_args { + public: + + ThriftHiveMetastore_get_table_meta_args(const ThriftHiveMetastore_get_table_meta_args&); + ThriftHiveMetastore_get_table_meta_args& operator=(const ThriftHiveMetastore_get_table_meta_args&); + ThriftHiveMetastore_get_table_meta_args() noexcept; + + virtual ~ThriftHiveMetastore_get_table_meta_args() noexcept; + std::string db_patterns; + std::string tbl_patterns; + std::vector tbl_types; + + _ThriftHiveMetastore_get_table_meta_args__isset __isset; + + void __set_db_patterns(const std::string& val); + + void __set_tbl_patterns(const std::string& val); + + void __set_tbl_types(const std::vector & val); + + bool operator == (const ThriftHiveMetastore_get_table_meta_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_table_meta_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_table_meta_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_table_meta_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_table_meta_pargs() noexcept; + const std::string* db_patterns; + const std::string* tbl_patterns; + const std::vector * tbl_types; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_table_meta_result__isset { + _ThriftHiveMetastore_get_table_meta_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_table_meta_result__isset; + +class ThriftHiveMetastore_get_table_meta_result { + public: + + ThriftHiveMetastore_get_table_meta_result(const ThriftHiveMetastore_get_table_meta_result&); + ThriftHiveMetastore_get_table_meta_result& operator=(const ThriftHiveMetastore_get_table_meta_result&); + ThriftHiveMetastore_get_table_meta_result() noexcept; + + virtual ~ThriftHiveMetastore_get_table_meta_result() noexcept; + std::vector success; + MetaException o1; + + _ThriftHiveMetastore_get_table_meta_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_table_meta_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_table_meta_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_table_meta_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_table_meta_presult__isset { + _ThriftHiveMetastore_get_table_meta_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_table_meta_presult__isset; + +class ThriftHiveMetastore_get_table_meta_presult { + public: + + + virtual ~ThriftHiveMetastore_get_table_meta_presult() noexcept; + std::vector * success; + MetaException o1; + + _ThriftHiveMetastore_get_table_meta_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_all_tables_args__isset { + _ThriftHiveMetastore_get_all_tables_args__isset() : db_name(false) {} + bool db_name :1; +} _ThriftHiveMetastore_get_all_tables_args__isset; + +class ThriftHiveMetastore_get_all_tables_args { + public: + + ThriftHiveMetastore_get_all_tables_args(const ThriftHiveMetastore_get_all_tables_args&); + ThriftHiveMetastore_get_all_tables_args& operator=(const ThriftHiveMetastore_get_all_tables_args&); + ThriftHiveMetastore_get_all_tables_args() noexcept; + + virtual ~ThriftHiveMetastore_get_all_tables_args() noexcept; + std::string db_name; + + _ThriftHiveMetastore_get_all_tables_args__isset __isset; + + void __set_db_name(const std::string& val); + + bool operator == (const ThriftHiveMetastore_get_all_tables_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_all_tables_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_all_tables_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_all_tables_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_all_tables_pargs() noexcept; + const std::string* db_name; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_all_tables_result__isset { + _ThriftHiveMetastore_get_all_tables_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_all_tables_result__isset; + +class ThriftHiveMetastore_get_all_tables_result { + public: + + ThriftHiveMetastore_get_all_tables_result(const ThriftHiveMetastore_get_all_tables_result&); + ThriftHiveMetastore_get_all_tables_result& operator=(const ThriftHiveMetastore_get_all_tables_result&); + ThriftHiveMetastore_get_all_tables_result() noexcept; + + virtual ~ThriftHiveMetastore_get_all_tables_result() noexcept; + std::vector success; + MetaException o1; + + _ThriftHiveMetastore_get_all_tables_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_all_tables_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_all_tables_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_all_tables_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_all_tables_presult__isset { + _ThriftHiveMetastore_get_all_tables_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_all_tables_presult__isset; + +class ThriftHiveMetastore_get_all_tables_presult { + public: + + + virtual ~ThriftHiveMetastore_get_all_tables_presult() noexcept; + std::vector * success; + MetaException o1; + + _ThriftHiveMetastore_get_all_tables_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_tables_ext_args__isset { + _ThriftHiveMetastore_get_tables_ext_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_get_tables_ext_args__isset; + +class ThriftHiveMetastore_get_tables_ext_args { + public: + + ThriftHiveMetastore_get_tables_ext_args(const ThriftHiveMetastore_get_tables_ext_args&); + ThriftHiveMetastore_get_tables_ext_args& operator=(const ThriftHiveMetastore_get_tables_ext_args&); + ThriftHiveMetastore_get_tables_ext_args() noexcept; + + virtual ~ThriftHiveMetastore_get_tables_ext_args() noexcept; + GetTablesExtRequest req; + + _ThriftHiveMetastore_get_tables_ext_args__isset __isset; + + void __set_req(const GetTablesExtRequest& val); + + bool operator == (const ThriftHiveMetastore_get_tables_ext_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_tables_ext_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_tables_ext_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_tables_ext_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_tables_ext_pargs() noexcept; + const GetTablesExtRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_tables_ext_result__isset { + _ThriftHiveMetastore_get_tables_ext_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_tables_ext_result__isset; + +class ThriftHiveMetastore_get_tables_ext_result { + public: + + ThriftHiveMetastore_get_tables_ext_result(const ThriftHiveMetastore_get_tables_ext_result&); + ThriftHiveMetastore_get_tables_ext_result& operator=(const ThriftHiveMetastore_get_tables_ext_result&); + ThriftHiveMetastore_get_tables_ext_result() noexcept; + + virtual ~ThriftHiveMetastore_get_tables_ext_result() noexcept; + std::vector success; + MetaException o1; + + _ThriftHiveMetastore_get_tables_ext_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_tables_ext_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_tables_ext_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_tables_ext_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_tables_ext_presult__isset { + _ThriftHiveMetastore_get_tables_ext_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_tables_ext_presult__isset; + +class ThriftHiveMetastore_get_tables_ext_presult { + public: + + + virtual ~ThriftHiveMetastore_get_tables_ext_presult() noexcept; + std::vector * success; + MetaException o1; + + _ThriftHiveMetastore_get_tables_ext_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_table_req_args__isset { + _ThriftHiveMetastore_get_table_req_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_get_table_req_args__isset; + +class ThriftHiveMetastore_get_table_req_args { + public: + + ThriftHiveMetastore_get_table_req_args(const ThriftHiveMetastore_get_table_req_args&); + ThriftHiveMetastore_get_table_req_args& operator=(const ThriftHiveMetastore_get_table_req_args&); + ThriftHiveMetastore_get_table_req_args() noexcept; + + virtual ~ThriftHiveMetastore_get_table_req_args() noexcept; + GetTableRequest req; + + _ThriftHiveMetastore_get_table_req_args__isset __isset; + + void __set_req(const GetTableRequest& val); + + bool operator == (const ThriftHiveMetastore_get_table_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_table_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_table_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_table_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_table_req_pargs() noexcept; + const GetTableRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_table_req_result__isset { + _ThriftHiveMetastore_get_table_req_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_table_req_result__isset; + +class ThriftHiveMetastore_get_table_req_result { + public: + + ThriftHiveMetastore_get_table_req_result(const ThriftHiveMetastore_get_table_req_result&); + ThriftHiveMetastore_get_table_req_result& operator=(const ThriftHiveMetastore_get_table_req_result&); + ThriftHiveMetastore_get_table_req_result() noexcept; + + virtual ~ThriftHiveMetastore_get_table_req_result() noexcept; + GetTableResult success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_table_req_result__isset __isset; + + void __set_success(const GetTableResult& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_table_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_table_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_table_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_table_req_presult__isset { + _ThriftHiveMetastore_get_table_req_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_table_req_presult__isset; + +class ThriftHiveMetastore_get_table_req_presult { + public: + + + virtual ~ThriftHiveMetastore_get_table_req_presult() noexcept; + GetTableResult* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_table_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_table_objects_by_name_req_args__isset { + _ThriftHiveMetastore_get_table_objects_by_name_req_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_get_table_objects_by_name_req_args__isset; + +class ThriftHiveMetastore_get_table_objects_by_name_req_args { + public: + + ThriftHiveMetastore_get_table_objects_by_name_req_args(const ThriftHiveMetastore_get_table_objects_by_name_req_args&); + ThriftHiveMetastore_get_table_objects_by_name_req_args& operator=(const ThriftHiveMetastore_get_table_objects_by_name_req_args&); + ThriftHiveMetastore_get_table_objects_by_name_req_args() noexcept; + + virtual ~ThriftHiveMetastore_get_table_objects_by_name_req_args() noexcept; + GetTablesRequest req; + + _ThriftHiveMetastore_get_table_objects_by_name_req_args__isset __isset; + + void __set_req(const GetTablesRequest& val); + + bool operator == (const ThriftHiveMetastore_get_table_objects_by_name_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_table_objects_by_name_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_table_objects_by_name_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_table_objects_by_name_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_table_objects_by_name_req_pargs() noexcept; + const GetTablesRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_table_objects_by_name_req_result__isset { + _ThriftHiveMetastore_get_table_objects_by_name_req_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_get_table_objects_by_name_req_result__isset; + +class ThriftHiveMetastore_get_table_objects_by_name_req_result { + public: + + ThriftHiveMetastore_get_table_objects_by_name_req_result(const ThriftHiveMetastore_get_table_objects_by_name_req_result&); + ThriftHiveMetastore_get_table_objects_by_name_req_result& operator=(const ThriftHiveMetastore_get_table_objects_by_name_req_result&); + ThriftHiveMetastore_get_table_objects_by_name_req_result() noexcept; + + virtual ~ThriftHiveMetastore_get_table_objects_by_name_req_result() noexcept; + GetTablesResult success; + MetaException o1; + InvalidOperationException o2; + UnknownDBException o3; + + _ThriftHiveMetastore_get_table_objects_by_name_req_result__isset __isset; + + void __set_success(const GetTablesResult& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const InvalidOperationException& val); + + void __set_o3(const UnknownDBException& val); + + bool operator == (const ThriftHiveMetastore_get_table_objects_by_name_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_table_objects_by_name_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_table_objects_by_name_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_table_objects_by_name_req_presult__isset { + _ThriftHiveMetastore_get_table_objects_by_name_req_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_get_table_objects_by_name_req_presult__isset; + +class ThriftHiveMetastore_get_table_objects_by_name_req_presult { + public: + + + virtual ~ThriftHiveMetastore_get_table_objects_by_name_req_presult() noexcept; + GetTablesResult* success; + MetaException o1; + InvalidOperationException o2; + UnknownDBException o3; + + _ThriftHiveMetastore_get_table_objects_by_name_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_materialization_invalidation_info_args__isset { + _ThriftHiveMetastore_get_materialization_invalidation_info_args__isset() : creation_metadata(false), validTxnList(false) {} + bool creation_metadata :1; + bool validTxnList :1; +} _ThriftHiveMetastore_get_materialization_invalidation_info_args__isset; + +class ThriftHiveMetastore_get_materialization_invalidation_info_args { + public: + + ThriftHiveMetastore_get_materialization_invalidation_info_args(const ThriftHiveMetastore_get_materialization_invalidation_info_args&); + ThriftHiveMetastore_get_materialization_invalidation_info_args& operator=(const ThriftHiveMetastore_get_materialization_invalidation_info_args&); + ThriftHiveMetastore_get_materialization_invalidation_info_args() noexcept; + + virtual ~ThriftHiveMetastore_get_materialization_invalidation_info_args() noexcept; + CreationMetadata creation_metadata; + std::string validTxnList; + + _ThriftHiveMetastore_get_materialization_invalidation_info_args__isset __isset; + + void __set_creation_metadata(const CreationMetadata& val); + + void __set_validTxnList(const std::string& val); + + bool operator == (const ThriftHiveMetastore_get_materialization_invalidation_info_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_materialization_invalidation_info_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_materialization_invalidation_info_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_materialization_invalidation_info_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_materialization_invalidation_info_pargs() noexcept; + const CreationMetadata* creation_metadata; + const std::string* validTxnList; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_materialization_invalidation_info_result__isset { + _ThriftHiveMetastore_get_materialization_invalidation_info_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_get_materialization_invalidation_info_result__isset; + +class ThriftHiveMetastore_get_materialization_invalidation_info_result { + public: + + ThriftHiveMetastore_get_materialization_invalidation_info_result(const ThriftHiveMetastore_get_materialization_invalidation_info_result&); + ThriftHiveMetastore_get_materialization_invalidation_info_result& operator=(const ThriftHiveMetastore_get_materialization_invalidation_info_result&); + ThriftHiveMetastore_get_materialization_invalidation_info_result() noexcept; + + virtual ~ThriftHiveMetastore_get_materialization_invalidation_info_result() noexcept; + Materialization success; + MetaException o1; + InvalidOperationException o2; + UnknownDBException o3; + + _ThriftHiveMetastore_get_materialization_invalidation_info_result__isset __isset; + + void __set_success(const Materialization& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const InvalidOperationException& val); + + void __set_o3(const UnknownDBException& val); + + bool operator == (const ThriftHiveMetastore_get_materialization_invalidation_info_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_materialization_invalidation_info_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_materialization_invalidation_info_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_materialization_invalidation_info_presult__isset { + _ThriftHiveMetastore_get_materialization_invalidation_info_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_get_materialization_invalidation_info_presult__isset; + +class ThriftHiveMetastore_get_materialization_invalidation_info_presult { + public: + + + virtual ~ThriftHiveMetastore_get_materialization_invalidation_info_presult() noexcept; + Materialization* success; + MetaException o1; + InvalidOperationException o2; + UnknownDBException o3; + + _ThriftHiveMetastore_get_materialization_invalidation_info_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_update_creation_metadata_args__isset { + _ThriftHiveMetastore_update_creation_metadata_args__isset() : catName(false), dbname(false), tbl_name(false), creation_metadata(false) {} + bool catName :1; + bool dbname :1; + bool tbl_name :1; + bool creation_metadata :1; +} _ThriftHiveMetastore_update_creation_metadata_args__isset; + +class ThriftHiveMetastore_update_creation_metadata_args { + public: + + ThriftHiveMetastore_update_creation_metadata_args(const ThriftHiveMetastore_update_creation_metadata_args&); + ThriftHiveMetastore_update_creation_metadata_args& operator=(const ThriftHiveMetastore_update_creation_metadata_args&); + ThriftHiveMetastore_update_creation_metadata_args() noexcept; + + virtual ~ThriftHiveMetastore_update_creation_metadata_args() noexcept; + std::string catName; + std::string dbname; + std::string tbl_name; + CreationMetadata creation_metadata; + + _ThriftHiveMetastore_update_creation_metadata_args__isset __isset; + + void __set_catName(const std::string& val); + + void __set_dbname(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_creation_metadata(const CreationMetadata& val); + + bool operator == (const ThriftHiveMetastore_update_creation_metadata_args & rhs) const; + bool operator != (const ThriftHiveMetastore_update_creation_metadata_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_update_creation_metadata_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_update_creation_metadata_pargs { + public: + + + virtual ~ThriftHiveMetastore_update_creation_metadata_pargs() noexcept; + const std::string* catName; + const std::string* dbname; + const std::string* tbl_name; + const CreationMetadata* creation_metadata; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_update_creation_metadata_result__isset { + _ThriftHiveMetastore_update_creation_metadata_result__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_update_creation_metadata_result__isset; + +class ThriftHiveMetastore_update_creation_metadata_result { + public: + + ThriftHiveMetastore_update_creation_metadata_result(const ThriftHiveMetastore_update_creation_metadata_result&); + ThriftHiveMetastore_update_creation_metadata_result& operator=(const ThriftHiveMetastore_update_creation_metadata_result&); + ThriftHiveMetastore_update_creation_metadata_result() noexcept; + + virtual ~ThriftHiveMetastore_update_creation_metadata_result() noexcept; + MetaException o1; + InvalidOperationException o2; + UnknownDBException o3; + + _ThriftHiveMetastore_update_creation_metadata_result__isset __isset; + + void __set_o1(const MetaException& val); + + void __set_o2(const InvalidOperationException& val); + + void __set_o3(const UnknownDBException& val); + + bool operator == (const ThriftHiveMetastore_update_creation_metadata_result & rhs) const; + bool operator != (const ThriftHiveMetastore_update_creation_metadata_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_update_creation_metadata_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_update_creation_metadata_presult__isset { + _ThriftHiveMetastore_update_creation_metadata_presult__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_update_creation_metadata_presult__isset; + +class ThriftHiveMetastore_update_creation_metadata_presult { + public: + + + virtual ~ThriftHiveMetastore_update_creation_metadata_presult() noexcept; + MetaException o1; + InvalidOperationException o2; + UnknownDBException o3; + + _ThriftHiveMetastore_update_creation_metadata_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_table_names_by_filter_args__isset { + _ThriftHiveMetastore_get_table_names_by_filter_args__isset() : dbname(false), filter(false), max_tables(true) {} + bool dbname :1; + bool filter :1; + bool max_tables :1; +} _ThriftHiveMetastore_get_table_names_by_filter_args__isset; + +class ThriftHiveMetastore_get_table_names_by_filter_args { + public: + + ThriftHiveMetastore_get_table_names_by_filter_args(const ThriftHiveMetastore_get_table_names_by_filter_args&); + ThriftHiveMetastore_get_table_names_by_filter_args& operator=(const ThriftHiveMetastore_get_table_names_by_filter_args&); + ThriftHiveMetastore_get_table_names_by_filter_args() noexcept; + + virtual ~ThriftHiveMetastore_get_table_names_by_filter_args() noexcept; + std::string dbname; + std::string filter; + int16_t max_tables; + + _ThriftHiveMetastore_get_table_names_by_filter_args__isset __isset; + + void __set_dbname(const std::string& val); + + void __set_filter(const std::string& val); + + void __set_max_tables(const int16_t val); + + bool operator == (const ThriftHiveMetastore_get_table_names_by_filter_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_table_names_by_filter_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_table_names_by_filter_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_table_names_by_filter_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_table_names_by_filter_pargs() noexcept; + const std::string* dbname; + const std::string* filter; + const int16_t* max_tables; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_table_names_by_filter_result__isset { + _ThriftHiveMetastore_get_table_names_by_filter_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_get_table_names_by_filter_result__isset; + +class ThriftHiveMetastore_get_table_names_by_filter_result { + public: + + ThriftHiveMetastore_get_table_names_by_filter_result(const ThriftHiveMetastore_get_table_names_by_filter_result&); + ThriftHiveMetastore_get_table_names_by_filter_result& operator=(const ThriftHiveMetastore_get_table_names_by_filter_result&); + ThriftHiveMetastore_get_table_names_by_filter_result() noexcept; + + virtual ~ThriftHiveMetastore_get_table_names_by_filter_result() noexcept; + std::vector success; + MetaException o1; + InvalidOperationException o2; + UnknownDBException o3; + + _ThriftHiveMetastore_get_table_names_by_filter_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + void __set_o2(const InvalidOperationException& val); + + void __set_o3(const UnknownDBException& val); + + bool operator == (const ThriftHiveMetastore_get_table_names_by_filter_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_table_names_by_filter_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_table_names_by_filter_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_table_names_by_filter_presult__isset { + _ThriftHiveMetastore_get_table_names_by_filter_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_get_table_names_by_filter_presult__isset; + +class ThriftHiveMetastore_get_table_names_by_filter_presult { + public: + + + virtual ~ThriftHiveMetastore_get_table_names_by_filter_presult() noexcept; + std::vector * success; + MetaException o1; + InvalidOperationException o2; + UnknownDBException o3; + + _ThriftHiveMetastore_get_table_names_by_filter_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_alter_table_args__isset { + _ThriftHiveMetastore_alter_table_args__isset() : dbname(false), tbl_name(false), new_tbl(false) {} + bool dbname :1; + bool tbl_name :1; + bool new_tbl :1; +} _ThriftHiveMetastore_alter_table_args__isset; + +class ThriftHiveMetastore_alter_table_args { + public: + + ThriftHiveMetastore_alter_table_args(const ThriftHiveMetastore_alter_table_args&); + ThriftHiveMetastore_alter_table_args& operator=(const ThriftHiveMetastore_alter_table_args&); + ThriftHiveMetastore_alter_table_args() noexcept; + + virtual ~ThriftHiveMetastore_alter_table_args() noexcept; + std::string dbname; + std::string tbl_name; + Table new_tbl; + + _ThriftHiveMetastore_alter_table_args__isset __isset; + + void __set_dbname(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_new_tbl(const Table& val); + + bool operator == (const ThriftHiveMetastore_alter_table_args & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_table_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_table_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_alter_table_pargs { + public: + + + virtual ~ThriftHiveMetastore_alter_table_pargs() noexcept; + const std::string* dbname; + const std::string* tbl_name; + const Table* new_tbl; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_table_result__isset { + _ThriftHiveMetastore_alter_table_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_table_result__isset; + +class ThriftHiveMetastore_alter_table_result { + public: + + ThriftHiveMetastore_alter_table_result(const ThriftHiveMetastore_alter_table_result&); + ThriftHiveMetastore_alter_table_result& operator=(const ThriftHiveMetastore_alter_table_result&); + ThriftHiveMetastore_alter_table_result() noexcept; + + virtual ~ThriftHiveMetastore_alter_table_result() noexcept; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_table_result__isset __isset; + + void __set_o1(const InvalidOperationException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_alter_table_result & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_table_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_table_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_table_presult__isset { + _ThriftHiveMetastore_alter_table_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_table_presult__isset; + +class ThriftHiveMetastore_alter_table_presult { + public: + + + virtual ~ThriftHiveMetastore_alter_table_presult() noexcept; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_table_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_alter_table_with_environment_context_args__isset { + _ThriftHiveMetastore_alter_table_with_environment_context_args__isset() : dbname(false), tbl_name(false), new_tbl(false), environment_context(false) {} + bool dbname :1; + bool tbl_name :1; + bool new_tbl :1; + bool environment_context :1; +} _ThriftHiveMetastore_alter_table_with_environment_context_args__isset; + +class ThriftHiveMetastore_alter_table_with_environment_context_args { + public: + + ThriftHiveMetastore_alter_table_with_environment_context_args(const ThriftHiveMetastore_alter_table_with_environment_context_args&); + ThriftHiveMetastore_alter_table_with_environment_context_args& operator=(const ThriftHiveMetastore_alter_table_with_environment_context_args&); + ThriftHiveMetastore_alter_table_with_environment_context_args() noexcept; + + virtual ~ThriftHiveMetastore_alter_table_with_environment_context_args() noexcept; + std::string dbname; + std::string tbl_name; + Table new_tbl; + EnvironmentContext environment_context; + + _ThriftHiveMetastore_alter_table_with_environment_context_args__isset __isset; + + void __set_dbname(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_new_tbl(const Table& val); + + void __set_environment_context(const EnvironmentContext& val); + + bool operator == (const ThriftHiveMetastore_alter_table_with_environment_context_args & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_table_with_environment_context_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_table_with_environment_context_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_alter_table_with_environment_context_pargs { + public: + + + virtual ~ThriftHiveMetastore_alter_table_with_environment_context_pargs() noexcept; + const std::string* dbname; + const std::string* tbl_name; + const Table* new_tbl; + const EnvironmentContext* environment_context; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_table_with_environment_context_result__isset { + _ThriftHiveMetastore_alter_table_with_environment_context_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_table_with_environment_context_result__isset; + +class ThriftHiveMetastore_alter_table_with_environment_context_result { + public: + + ThriftHiveMetastore_alter_table_with_environment_context_result(const ThriftHiveMetastore_alter_table_with_environment_context_result&); + ThriftHiveMetastore_alter_table_with_environment_context_result& operator=(const ThriftHiveMetastore_alter_table_with_environment_context_result&); + ThriftHiveMetastore_alter_table_with_environment_context_result() noexcept; + + virtual ~ThriftHiveMetastore_alter_table_with_environment_context_result() noexcept; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_table_with_environment_context_result__isset __isset; + + void __set_o1(const InvalidOperationException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_alter_table_with_environment_context_result & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_table_with_environment_context_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_table_with_environment_context_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_table_with_environment_context_presult__isset { + _ThriftHiveMetastore_alter_table_with_environment_context_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_table_with_environment_context_presult__isset; + +class ThriftHiveMetastore_alter_table_with_environment_context_presult { + public: + + + virtual ~ThriftHiveMetastore_alter_table_with_environment_context_presult() noexcept; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_table_with_environment_context_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_alter_table_with_cascade_args__isset { + _ThriftHiveMetastore_alter_table_with_cascade_args__isset() : dbname(false), tbl_name(false), new_tbl(false), cascade(false) {} + bool dbname :1; + bool tbl_name :1; + bool new_tbl :1; + bool cascade :1; +} _ThriftHiveMetastore_alter_table_with_cascade_args__isset; + +class ThriftHiveMetastore_alter_table_with_cascade_args { + public: + + ThriftHiveMetastore_alter_table_with_cascade_args(const ThriftHiveMetastore_alter_table_with_cascade_args&); + ThriftHiveMetastore_alter_table_with_cascade_args& operator=(const ThriftHiveMetastore_alter_table_with_cascade_args&); + ThriftHiveMetastore_alter_table_with_cascade_args() noexcept; + + virtual ~ThriftHiveMetastore_alter_table_with_cascade_args() noexcept; + std::string dbname; + std::string tbl_name; + Table new_tbl; + bool cascade; + + _ThriftHiveMetastore_alter_table_with_cascade_args__isset __isset; + + void __set_dbname(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_new_tbl(const Table& val); + + void __set_cascade(const bool val); + + bool operator == (const ThriftHiveMetastore_alter_table_with_cascade_args & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_table_with_cascade_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_table_with_cascade_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_alter_table_with_cascade_pargs { + public: + + + virtual ~ThriftHiveMetastore_alter_table_with_cascade_pargs() noexcept; + const std::string* dbname; + const std::string* tbl_name; + const Table* new_tbl; + const bool* cascade; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_table_with_cascade_result__isset { + _ThriftHiveMetastore_alter_table_with_cascade_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_table_with_cascade_result__isset; + +class ThriftHiveMetastore_alter_table_with_cascade_result { + public: + + ThriftHiveMetastore_alter_table_with_cascade_result(const ThriftHiveMetastore_alter_table_with_cascade_result&); + ThriftHiveMetastore_alter_table_with_cascade_result& operator=(const ThriftHiveMetastore_alter_table_with_cascade_result&); + ThriftHiveMetastore_alter_table_with_cascade_result() noexcept; + + virtual ~ThriftHiveMetastore_alter_table_with_cascade_result() noexcept; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_table_with_cascade_result__isset __isset; + + void __set_o1(const InvalidOperationException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_alter_table_with_cascade_result & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_table_with_cascade_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_table_with_cascade_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_table_with_cascade_presult__isset { + _ThriftHiveMetastore_alter_table_with_cascade_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_table_with_cascade_presult__isset; + +class ThriftHiveMetastore_alter_table_with_cascade_presult { + public: + + + virtual ~ThriftHiveMetastore_alter_table_with_cascade_presult() noexcept; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_table_with_cascade_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_alter_table_req_args__isset { + _ThriftHiveMetastore_alter_table_req_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_alter_table_req_args__isset; + +class ThriftHiveMetastore_alter_table_req_args { + public: + + ThriftHiveMetastore_alter_table_req_args(const ThriftHiveMetastore_alter_table_req_args&); + ThriftHiveMetastore_alter_table_req_args& operator=(const ThriftHiveMetastore_alter_table_req_args&); + ThriftHiveMetastore_alter_table_req_args() noexcept; + + virtual ~ThriftHiveMetastore_alter_table_req_args() noexcept; + AlterTableRequest req; + + _ThriftHiveMetastore_alter_table_req_args__isset __isset; + + void __set_req(const AlterTableRequest& val); + + bool operator == (const ThriftHiveMetastore_alter_table_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_table_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_table_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_alter_table_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_alter_table_req_pargs() noexcept; + const AlterTableRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_table_req_result__isset { + _ThriftHiveMetastore_alter_table_req_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_table_req_result__isset; + +class ThriftHiveMetastore_alter_table_req_result { + public: + + ThriftHiveMetastore_alter_table_req_result(const ThriftHiveMetastore_alter_table_req_result&); + ThriftHiveMetastore_alter_table_req_result& operator=(const ThriftHiveMetastore_alter_table_req_result&); + ThriftHiveMetastore_alter_table_req_result() noexcept; + + virtual ~ThriftHiveMetastore_alter_table_req_result() noexcept; + AlterTableResponse success; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_table_req_result__isset __isset; + + void __set_success(const AlterTableResponse& val); + + void __set_o1(const InvalidOperationException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_alter_table_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_table_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_table_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_table_req_presult__isset { + _ThriftHiveMetastore_alter_table_req_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_table_req_presult__isset; + +class ThriftHiveMetastore_alter_table_req_presult { + public: + + + virtual ~ThriftHiveMetastore_alter_table_req_presult() noexcept; + AlterTableResponse* success; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_table_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_add_partition_args__isset { + _ThriftHiveMetastore_add_partition_args__isset() : new_part(false) {} + bool new_part :1; +} _ThriftHiveMetastore_add_partition_args__isset; + +class ThriftHiveMetastore_add_partition_args { + public: + + ThriftHiveMetastore_add_partition_args(const ThriftHiveMetastore_add_partition_args&); + ThriftHiveMetastore_add_partition_args& operator=(const ThriftHiveMetastore_add_partition_args&); + ThriftHiveMetastore_add_partition_args() noexcept; + + virtual ~ThriftHiveMetastore_add_partition_args() noexcept; + Partition new_part; + + _ThriftHiveMetastore_add_partition_args__isset __isset; + + void __set_new_part(const Partition& val); + + bool operator == (const ThriftHiveMetastore_add_partition_args & rhs) const; + bool operator != (const ThriftHiveMetastore_add_partition_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_partition_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_partition_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_partition_pargs() noexcept; + const Partition* new_part; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_partition_result__isset { + _ThriftHiveMetastore_add_partition_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_add_partition_result__isset; + +class ThriftHiveMetastore_add_partition_result { + public: + + ThriftHiveMetastore_add_partition_result(const ThriftHiveMetastore_add_partition_result&); + ThriftHiveMetastore_add_partition_result& operator=(const ThriftHiveMetastore_add_partition_result&); + ThriftHiveMetastore_add_partition_result() noexcept; + + virtual ~ThriftHiveMetastore_add_partition_result() noexcept; + Partition success; + InvalidObjectException o1; + AlreadyExistsException o2; + MetaException o3; + + _ThriftHiveMetastore_add_partition_result__isset __isset; + + void __set_success(const Partition& val); + + void __set_o1(const InvalidObjectException& val); + + void __set_o2(const AlreadyExistsException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_add_partition_result & rhs) const; + bool operator != (const ThriftHiveMetastore_add_partition_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_partition_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_partition_presult__isset { + _ThriftHiveMetastore_add_partition_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_add_partition_presult__isset; + +class ThriftHiveMetastore_add_partition_presult { + public: + + + virtual ~ThriftHiveMetastore_add_partition_presult() noexcept; + Partition* success; + InvalidObjectException o1; + AlreadyExistsException o2; + MetaException o3; + + _ThriftHiveMetastore_add_partition_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_add_partition_with_environment_context_args__isset { + _ThriftHiveMetastore_add_partition_with_environment_context_args__isset() : new_part(false), environment_context(false) {} + bool new_part :1; + bool environment_context :1; +} _ThriftHiveMetastore_add_partition_with_environment_context_args__isset; + +class ThriftHiveMetastore_add_partition_with_environment_context_args { + public: + + ThriftHiveMetastore_add_partition_with_environment_context_args(const ThriftHiveMetastore_add_partition_with_environment_context_args&); + ThriftHiveMetastore_add_partition_with_environment_context_args& operator=(const ThriftHiveMetastore_add_partition_with_environment_context_args&); + ThriftHiveMetastore_add_partition_with_environment_context_args() noexcept; + + virtual ~ThriftHiveMetastore_add_partition_with_environment_context_args() noexcept; + Partition new_part; + EnvironmentContext environment_context; + + _ThriftHiveMetastore_add_partition_with_environment_context_args__isset __isset; + + void __set_new_part(const Partition& val); + + void __set_environment_context(const EnvironmentContext& val); + + bool operator == (const ThriftHiveMetastore_add_partition_with_environment_context_args & rhs) const; + bool operator != (const ThriftHiveMetastore_add_partition_with_environment_context_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_partition_with_environment_context_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_partition_with_environment_context_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_partition_with_environment_context_pargs() noexcept; + const Partition* new_part; + const EnvironmentContext* environment_context; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_partition_with_environment_context_result__isset { + _ThriftHiveMetastore_add_partition_with_environment_context_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_add_partition_with_environment_context_result__isset; + +class ThriftHiveMetastore_add_partition_with_environment_context_result { + public: + + ThriftHiveMetastore_add_partition_with_environment_context_result(const ThriftHiveMetastore_add_partition_with_environment_context_result&); + ThriftHiveMetastore_add_partition_with_environment_context_result& operator=(const ThriftHiveMetastore_add_partition_with_environment_context_result&); + ThriftHiveMetastore_add_partition_with_environment_context_result() noexcept; + + virtual ~ThriftHiveMetastore_add_partition_with_environment_context_result() noexcept; + Partition success; + InvalidObjectException o1; + AlreadyExistsException o2; + MetaException o3; + + _ThriftHiveMetastore_add_partition_with_environment_context_result__isset __isset; + + void __set_success(const Partition& val); + + void __set_o1(const InvalidObjectException& val); + + void __set_o2(const AlreadyExistsException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_add_partition_with_environment_context_result & rhs) const; + bool operator != (const ThriftHiveMetastore_add_partition_with_environment_context_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_partition_with_environment_context_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_partition_with_environment_context_presult__isset { + _ThriftHiveMetastore_add_partition_with_environment_context_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_add_partition_with_environment_context_presult__isset; + +class ThriftHiveMetastore_add_partition_with_environment_context_presult { + public: + + + virtual ~ThriftHiveMetastore_add_partition_with_environment_context_presult() noexcept; + Partition* success; + InvalidObjectException o1; + AlreadyExistsException o2; + MetaException o3; + + _ThriftHiveMetastore_add_partition_with_environment_context_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_add_partitions_args__isset { + _ThriftHiveMetastore_add_partitions_args__isset() : new_parts(false) {} + bool new_parts :1; +} _ThriftHiveMetastore_add_partitions_args__isset; + +class ThriftHiveMetastore_add_partitions_args { + public: + + ThriftHiveMetastore_add_partitions_args(const ThriftHiveMetastore_add_partitions_args&); + ThriftHiveMetastore_add_partitions_args& operator=(const ThriftHiveMetastore_add_partitions_args&); + ThriftHiveMetastore_add_partitions_args() noexcept; + + virtual ~ThriftHiveMetastore_add_partitions_args() noexcept; + std::vector new_parts; + + _ThriftHiveMetastore_add_partitions_args__isset __isset; + + void __set_new_parts(const std::vector & val); + + bool operator == (const ThriftHiveMetastore_add_partitions_args & rhs) const; + bool operator != (const ThriftHiveMetastore_add_partitions_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_partitions_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_partitions_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_partitions_pargs() noexcept; + const std::vector * new_parts; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_partitions_result__isset { + _ThriftHiveMetastore_add_partitions_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_add_partitions_result__isset; + +class ThriftHiveMetastore_add_partitions_result { + public: + + ThriftHiveMetastore_add_partitions_result(const ThriftHiveMetastore_add_partitions_result&); + ThriftHiveMetastore_add_partitions_result& operator=(const ThriftHiveMetastore_add_partitions_result&); + ThriftHiveMetastore_add_partitions_result() noexcept; + + virtual ~ThriftHiveMetastore_add_partitions_result() noexcept; + int32_t success; + InvalidObjectException o1; + AlreadyExistsException o2; + MetaException o3; + + _ThriftHiveMetastore_add_partitions_result__isset __isset; + + void __set_success(const int32_t val); + + void __set_o1(const InvalidObjectException& val); + + void __set_o2(const AlreadyExistsException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_add_partitions_result & rhs) const; + bool operator != (const ThriftHiveMetastore_add_partitions_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_partitions_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_partitions_presult__isset { + _ThriftHiveMetastore_add_partitions_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_add_partitions_presult__isset; + +class ThriftHiveMetastore_add_partitions_presult { + public: + + + virtual ~ThriftHiveMetastore_add_partitions_presult() noexcept; + int32_t* success; + InvalidObjectException o1; + AlreadyExistsException o2; + MetaException o3; + + _ThriftHiveMetastore_add_partitions_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_add_partitions_pspec_args__isset { + _ThriftHiveMetastore_add_partitions_pspec_args__isset() : new_parts(false) {} + bool new_parts :1; +} _ThriftHiveMetastore_add_partitions_pspec_args__isset; + +class ThriftHiveMetastore_add_partitions_pspec_args { + public: + + ThriftHiveMetastore_add_partitions_pspec_args(const ThriftHiveMetastore_add_partitions_pspec_args&); + ThriftHiveMetastore_add_partitions_pspec_args& operator=(const ThriftHiveMetastore_add_partitions_pspec_args&); + ThriftHiveMetastore_add_partitions_pspec_args() noexcept; + + virtual ~ThriftHiveMetastore_add_partitions_pspec_args() noexcept; + std::vector new_parts; + + _ThriftHiveMetastore_add_partitions_pspec_args__isset __isset; + + void __set_new_parts(const std::vector & val); + + bool operator == (const ThriftHiveMetastore_add_partitions_pspec_args & rhs) const; + bool operator != (const ThriftHiveMetastore_add_partitions_pspec_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_partitions_pspec_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_partitions_pspec_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_partitions_pspec_pargs() noexcept; + const std::vector * new_parts; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_partitions_pspec_result__isset { + _ThriftHiveMetastore_add_partitions_pspec_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_add_partitions_pspec_result__isset; + +class ThriftHiveMetastore_add_partitions_pspec_result { + public: + + ThriftHiveMetastore_add_partitions_pspec_result(const ThriftHiveMetastore_add_partitions_pspec_result&); + ThriftHiveMetastore_add_partitions_pspec_result& operator=(const ThriftHiveMetastore_add_partitions_pspec_result&); + ThriftHiveMetastore_add_partitions_pspec_result() noexcept; + + virtual ~ThriftHiveMetastore_add_partitions_pspec_result() noexcept; + int32_t success; + InvalidObjectException o1; + AlreadyExistsException o2; + MetaException o3; + + _ThriftHiveMetastore_add_partitions_pspec_result__isset __isset; + + void __set_success(const int32_t val); + + void __set_o1(const InvalidObjectException& val); + + void __set_o2(const AlreadyExistsException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_add_partitions_pspec_result & rhs) const; + bool operator != (const ThriftHiveMetastore_add_partitions_pspec_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_partitions_pspec_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_partitions_pspec_presult__isset { + _ThriftHiveMetastore_add_partitions_pspec_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_add_partitions_pspec_presult__isset; + +class ThriftHiveMetastore_add_partitions_pspec_presult { + public: + + + virtual ~ThriftHiveMetastore_add_partitions_pspec_presult() noexcept; + int32_t* success; + InvalidObjectException o1; + AlreadyExistsException o2; + MetaException o3; + + _ThriftHiveMetastore_add_partitions_pspec_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_append_partition_args__isset { + _ThriftHiveMetastore_append_partition_args__isset() : db_name(false), tbl_name(false), part_vals(false) {} + bool db_name :1; + bool tbl_name :1; + bool part_vals :1; +} _ThriftHiveMetastore_append_partition_args__isset; + +class ThriftHiveMetastore_append_partition_args { + public: + + ThriftHiveMetastore_append_partition_args(const ThriftHiveMetastore_append_partition_args&); + ThriftHiveMetastore_append_partition_args& operator=(const ThriftHiveMetastore_append_partition_args&); + ThriftHiveMetastore_append_partition_args() noexcept; + + virtual ~ThriftHiveMetastore_append_partition_args() noexcept; + std::string db_name; + std::string tbl_name; + std::vector part_vals; + + _ThriftHiveMetastore_append_partition_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_part_vals(const std::vector & val); + + bool operator == (const ThriftHiveMetastore_append_partition_args & rhs) const; + bool operator != (const ThriftHiveMetastore_append_partition_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_append_partition_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_append_partition_pargs { + public: + + + virtual ~ThriftHiveMetastore_append_partition_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::vector * part_vals; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_append_partition_result__isset { + _ThriftHiveMetastore_append_partition_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_append_partition_result__isset; + +class ThriftHiveMetastore_append_partition_result { + public: + + ThriftHiveMetastore_append_partition_result(const ThriftHiveMetastore_append_partition_result&); + ThriftHiveMetastore_append_partition_result& operator=(const ThriftHiveMetastore_append_partition_result&); + ThriftHiveMetastore_append_partition_result() noexcept; + + virtual ~ThriftHiveMetastore_append_partition_result() noexcept; + Partition success; + InvalidObjectException o1; + AlreadyExistsException o2; + MetaException o3; + + _ThriftHiveMetastore_append_partition_result__isset __isset; + + void __set_success(const Partition& val); + + void __set_o1(const InvalidObjectException& val); + + void __set_o2(const AlreadyExistsException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_append_partition_result & rhs) const; + bool operator != (const ThriftHiveMetastore_append_partition_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_append_partition_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_append_partition_presult__isset { + _ThriftHiveMetastore_append_partition_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_append_partition_presult__isset; + +class ThriftHiveMetastore_append_partition_presult { + public: + + + virtual ~ThriftHiveMetastore_append_partition_presult() noexcept; + Partition* success; + InvalidObjectException o1; + AlreadyExistsException o2; + MetaException o3; + + _ThriftHiveMetastore_append_partition_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_add_partitions_req_args__isset { + _ThriftHiveMetastore_add_partitions_req_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_add_partitions_req_args__isset; + +class ThriftHiveMetastore_add_partitions_req_args { + public: + + ThriftHiveMetastore_add_partitions_req_args(const ThriftHiveMetastore_add_partitions_req_args&); + ThriftHiveMetastore_add_partitions_req_args& operator=(const ThriftHiveMetastore_add_partitions_req_args&); + ThriftHiveMetastore_add_partitions_req_args() noexcept; + + virtual ~ThriftHiveMetastore_add_partitions_req_args() noexcept; + AddPartitionsRequest request; + + _ThriftHiveMetastore_add_partitions_req_args__isset __isset; + + void __set_request(const AddPartitionsRequest& val); + + bool operator == (const ThriftHiveMetastore_add_partitions_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_add_partitions_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_partitions_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_partitions_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_partitions_req_pargs() noexcept; + const AddPartitionsRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_partitions_req_result__isset { + _ThriftHiveMetastore_add_partitions_req_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_add_partitions_req_result__isset; + +class ThriftHiveMetastore_add_partitions_req_result { + public: + + ThriftHiveMetastore_add_partitions_req_result(const ThriftHiveMetastore_add_partitions_req_result&); + ThriftHiveMetastore_add_partitions_req_result& operator=(const ThriftHiveMetastore_add_partitions_req_result&); + ThriftHiveMetastore_add_partitions_req_result() noexcept; + + virtual ~ThriftHiveMetastore_add_partitions_req_result() noexcept; + AddPartitionsResult success; + InvalidObjectException o1; + AlreadyExistsException o2; + MetaException o3; + + _ThriftHiveMetastore_add_partitions_req_result__isset __isset; + + void __set_success(const AddPartitionsResult& val); + + void __set_o1(const InvalidObjectException& val); + + void __set_o2(const AlreadyExistsException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_add_partitions_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_add_partitions_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_partitions_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_partitions_req_presult__isset { + _ThriftHiveMetastore_add_partitions_req_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_add_partitions_req_presult__isset; + +class ThriftHiveMetastore_add_partitions_req_presult { + public: + + + virtual ~ThriftHiveMetastore_add_partitions_req_presult() noexcept; + AddPartitionsResult* success; + InvalidObjectException o1; + AlreadyExistsException o2; + MetaException o3; + + _ThriftHiveMetastore_add_partitions_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_append_partition_with_environment_context_args__isset { + _ThriftHiveMetastore_append_partition_with_environment_context_args__isset() : db_name(false), tbl_name(false), part_vals(false), environment_context(false) {} + bool db_name :1; + bool tbl_name :1; + bool part_vals :1; + bool environment_context :1; +} _ThriftHiveMetastore_append_partition_with_environment_context_args__isset; + +class ThriftHiveMetastore_append_partition_with_environment_context_args { + public: + + ThriftHiveMetastore_append_partition_with_environment_context_args(const ThriftHiveMetastore_append_partition_with_environment_context_args&); + ThriftHiveMetastore_append_partition_with_environment_context_args& operator=(const ThriftHiveMetastore_append_partition_with_environment_context_args&); + ThriftHiveMetastore_append_partition_with_environment_context_args() noexcept; + + virtual ~ThriftHiveMetastore_append_partition_with_environment_context_args() noexcept; + std::string db_name; + std::string tbl_name; + std::vector part_vals; + EnvironmentContext environment_context; + + _ThriftHiveMetastore_append_partition_with_environment_context_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_part_vals(const std::vector & val); + + void __set_environment_context(const EnvironmentContext& val); + + bool operator == (const ThriftHiveMetastore_append_partition_with_environment_context_args & rhs) const; + bool operator != (const ThriftHiveMetastore_append_partition_with_environment_context_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_append_partition_with_environment_context_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_append_partition_with_environment_context_pargs { + public: + + + virtual ~ThriftHiveMetastore_append_partition_with_environment_context_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::vector * part_vals; + const EnvironmentContext* environment_context; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_append_partition_with_environment_context_result__isset { + _ThriftHiveMetastore_append_partition_with_environment_context_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_append_partition_with_environment_context_result__isset; + +class ThriftHiveMetastore_append_partition_with_environment_context_result { + public: + + ThriftHiveMetastore_append_partition_with_environment_context_result(const ThriftHiveMetastore_append_partition_with_environment_context_result&); + ThriftHiveMetastore_append_partition_with_environment_context_result& operator=(const ThriftHiveMetastore_append_partition_with_environment_context_result&); + ThriftHiveMetastore_append_partition_with_environment_context_result() noexcept; + + virtual ~ThriftHiveMetastore_append_partition_with_environment_context_result() noexcept; + Partition success; + InvalidObjectException o1; + AlreadyExistsException o2; + MetaException o3; + + _ThriftHiveMetastore_append_partition_with_environment_context_result__isset __isset; + + void __set_success(const Partition& val); + + void __set_o1(const InvalidObjectException& val); + + void __set_o2(const AlreadyExistsException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_append_partition_with_environment_context_result & rhs) const; + bool operator != (const ThriftHiveMetastore_append_partition_with_environment_context_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_append_partition_with_environment_context_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_append_partition_with_environment_context_presult__isset { + _ThriftHiveMetastore_append_partition_with_environment_context_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_append_partition_with_environment_context_presult__isset; + +class ThriftHiveMetastore_append_partition_with_environment_context_presult { + public: + + + virtual ~ThriftHiveMetastore_append_partition_with_environment_context_presult() noexcept; + Partition* success; + InvalidObjectException o1; + AlreadyExistsException o2; + MetaException o3; + + _ThriftHiveMetastore_append_partition_with_environment_context_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_append_partition_req_args__isset { + _ThriftHiveMetastore_append_partition_req_args__isset() : appendPartitionsReq(false) {} + bool appendPartitionsReq :1; +} _ThriftHiveMetastore_append_partition_req_args__isset; + +class ThriftHiveMetastore_append_partition_req_args { + public: + + ThriftHiveMetastore_append_partition_req_args(const ThriftHiveMetastore_append_partition_req_args&); + ThriftHiveMetastore_append_partition_req_args& operator=(const ThriftHiveMetastore_append_partition_req_args&); + ThriftHiveMetastore_append_partition_req_args() noexcept; + + virtual ~ThriftHiveMetastore_append_partition_req_args() noexcept; + AppendPartitionsRequest appendPartitionsReq; + + _ThriftHiveMetastore_append_partition_req_args__isset __isset; + + void __set_appendPartitionsReq(const AppendPartitionsRequest& val); + + bool operator == (const ThriftHiveMetastore_append_partition_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_append_partition_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_append_partition_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_append_partition_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_append_partition_req_pargs() noexcept; + const AppendPartitionsRequest* appendPartitionsReq; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_append_partition_req_result__isset { + _ThriftHiveMetastore_append_partition_req_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_append_partition_req_result__isset; + +class ThriftHiveMetastore_append_partition_req_result { + public: + + ThriftHiveMetastore_append_partition_req_result(const ThriftHiveMetastore_append_partition_req_result&); + ThriftHiveMetastore_append_partition_req_result& operator=(const ThriftHiveMetastore_append_partition_req_result&); + ThriftHiveMetastore_append_partition_req_result() noexcept; + + virtual ~ThriftHiveMetastore_append_partition_req_result() noexcept; + Partition success; + InvalidObjectException o1; + AlreadyExistsException o2; + MetaException o3; + + _ThriftHiveMetastore_append_partition_req_result__isset __isset; + + void __set_success(const Partition& val); + + void __set_o1(const InvalidObjectException& val); + + void __set_o2(const AlreadyExistsException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_append_partition_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_append_partition_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_append_partition_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_append_partition_req_presult__isset { + _ThriftHiveMetastore_append_partition_req_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_append_partition_req_presult__isset; + +class ThriftHiveMetastore_append_partition_req_presult { + public: + + + virtual ~ThriftHiveMetastore_append_partition_req_presult() noexcept; + Partition* success; + InvalidObjectException o1; + AlreadyExistsException o2; + MetaException o3; + + _ThriftHiveMetastore_append_partition_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_append_partition_by_name_args__isset { + _ThriftHiveMetastore_append_partition_by_name_args__isset() : db_name(false), tbl_name(false), part_name(false) {} + bool db_name :1; + bool tbl_name :1; + bool part_name :1; +} _ThriftHiveMetastore_append_partition_by_name_args__isset; + +class ThriftHiveMetastore_append_partition_by_name_args { + public: + + ThriftHiveMetastore_append_partition_by_name_args(const ThriftHiveMetastore_append_partition_by_name_args&); + ThriftHiveMetastore_append_partition_by_name_args& operator=(const ThriftHiveMetastore_append_partition_by_name_args&); + ThriftHiveMetastore_append_partition_by_name_args() noexcept; + + virtual ~ThriftHiveMetastore_append_partition_by_name_args() noexcept; + std::string db_name; + std::string tbl_name; + std::string part_name; + + _ThriftHiveMetastore_append_partition_by_name_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_part_name(const std::string& val); + + bool operator == (const ThriftHiveMetastore_append_partition_by_name_args & rhs) const; + bool operator != (const ThriftHiveMetastore_append_partition_by_name_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_append_partition_by_name_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_append_partition_by_name_pargs { + public: + + + virtual ~ThriftHiveMetastore_append_partition_by_name_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::string* part_name; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_append_partition_by_name_result__isset { + _ThriftHiveMetastore_append_partition_by_name_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_append_partition_by_name_result__isset; + +class ThriftHiveMetastore_append_partition_by_name_result { + public: + + ThriftHiveMetastore_append_partition_by_name_result(const ThriftHiveMetastore_append_partition_by_name_result&); + ThriftHiveMetastore_append_partition_by_name_result& operator=(const ThriftHiveMetastore_append_partition_by_name_result&); + ThriftHiveMetastore_append_partition_by_name_result() noexcept; + + virtual ~ThriftHiveMetastore_append_partition_by_name_result() noexcept; + Partition success; + InvalidObjectException o1; + AlreadyExistsException o2; + MetaException o3; + + _ThriftHiveMetastore_append_partition_by_name_result__isset __isset; + + void __set_success(const Partition& val); + + void __set_o1(const InvalidObjectException& val); + + void __set_o2(const AlreadyExistsException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_append_partition_by_name_result & rhs) const; + bool operator != (const ThriftHiveMetastore_append_partition_by_name_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_append_partition_by_name_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_append_partition_by_name_presult__isset { + _ThriftHiveMetastore_append_partition_by_name_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_append_partition_by_name_presult__isset; + +class ThriftHiveMetastore_append_partition_by_name_presult { + public: + + + virtual ~ThriftHiveMetastore_append_partition_by_name_presult() noexcept; + Partition* success; + InvalidObjectException o1; + AlreadyExistsException o2; + MetaException o3; + + _ThriftHiveMetastore_append_partition_by_name_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_append_partition_by_name_with_environment_context_args__isset { + _ThriftHiveMetastore_append_partition_by_name_with_environment_context_args__isset() : db_name(false), tbl_name(false), part_name(false), environment_context(false) {} + bool db_name :1; + bool tbl_name :1; + bool part_name :1; + bool environment_context :1; +} _ThriftHiveMetastore_append_partition_by_name_with_environment_context_args__isset; + +class ThriftHiveMetastore_append_partition_by_name_with_environment_context_args { + public: + + ThriftHiveMetastore_append_partition_by_name_with_environment_context_args(const ThriftHiveMetastore_append_partition_by_name_with_environment_context_args&); + ThriftHiveMetastore_append_partition_by_name_with_environment_context_args& operator=(const ThriftHiveMetastore_append_partition_by_name_with_environment_context_args&); + ThriftHiveMetastore_append_partition_by_name_with_environment_context_args() noexcept; + + virtual ~ThriftHiveMetastore_append_partition_by_name_with_environment_context_args() noexcept; + std::string db_name; + std::string tbl_name; + std::string part_name; + EnvironmentContext environment_context; + + _ThriftHiveMetastore_append_partition_by_name_with_environment_context_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_part_name(const std::string& val); + + void __set_environment_context(const EnvironmentContext& val); + + bool operator == (const ThriftHiveMetastore_append_partition_by_name_with_environment_context_args & rhs) const; + bool operator != (const ThriftHiveMetastore_append_partition_by_name_with_environment_context_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_append_partition_by_name_with_environment_context_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_append_partition_by_name_with_environment_context_pargs { + public: + + + virtual ~ThriftHiveMetastore_append_partition_by_name_with_environment_context_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::string* part_name; + const EnvironmentContext* environment_context; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_append_partition_by_name_with_environment_context_result__isset { + _ThriftHiveMetastore_append_partition_by_name_with_environment_context_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_append_partition_by_name_with_environment_context_result__isset; + +class ThriftHiveMetastore_append_partition_by_name_with_environment_context_result { + public: + + ThriftHiveMetastore_append_partition_by_name_with_environment_context_result(const ThriftHiveMetastore_append_partition_by_name_with_environment_context_result&); + ThriftHiveMetastore_append_partition_by_name_with_environment_context_result& operator=(const ThriftHiveMetastore_append_partition_by_name_with_environment_context_result&); + ThriftHiveMetastore_append_partition_by_name_with_environment_context_result() noexcept; + + virtual ~ThriftHiveMetastore_append_partition_by_name_with_environment_context_result() noexcept; + Partition success; + InvalidObjectException o1; + AlreadyExistsException o2; + MetaException o3; + + _ThriftHiveMetastore_append_partition_by_name_with_environment_context_result__isset __isset; + + void __set_success(const Partition& val); + + void __set_o1(const InvalidObjectException& val); + + void __set_o2(const AlreadyExistsException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_append_partition_by_name_with_environment_context_result & rhs) const; + bool operator != (const ThriftHiveMetastore_append_partition_by_name_with_environment_context_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_append_partition_by_name_with_environment_context_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_append_partition_by_name_with_environment_context_presult__isset { + _ThriftHiveMetastore_append_partition_by_name_with_environment_context_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_append_partition_by_name_with_environment_context_presult__isset; + +class ThriftHiveMetastore_append_partition_by_name_with_environment_context_presult { + public: + + + virtual ~ThriftHiveMetastore_append_partition_by_name_with_environment_context_presult() noexcept; + Partition* success; + InvalidObjectException o1; + AlreadyExistsException o2; + MetaException o3; + + _ThriftHiveMetastore_append_partition_by_name_with_environment_context_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_partition_args__isset { + _ThriftHiveMetastore_drop_partition_args__isset() : db_name(false), tbl_name(false), part_vals(false), deleteData(false) {} + bool db_name :1; + bool tbl_name :1; + bool part_vals :1; + bool deleteData :1; +} _ThriftHiveMetastore_drop_partition_args__isset; + +class ThriftHiveMetastore_drop_partition_args { + public: + + ThriftHiveMetastore_drop_partition_args(const ThriftHiveMetastore_drop_partition_args&); + ThriftHiveMetastore_drop_partition_args& operator=(const ThriftHiveMetastore_drop_partition_args&); + ThriftHiveMetastore_drop_partition_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_partition_args() noexcept; + std::string db_name; + std::string tbl_name; + std::vector part_vals; + bool deleteData; + + _ThriftHiveMetastore_drop_partition_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_part_vals(const std::vector & val); + + void __set_deleteData(const bool val); + + bool operator == (const ThriftHiveMetastore_drop_partition_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_partition_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_partition_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_partition_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_partition_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::vector * part_vals; + const bool* deleteData; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_partition_result__isset { + _ThriftHiveMetastore_drop_partition_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_drop_partition_result__isset; + +class ThriftHiveMetastore_drop_partition_result { + public: + + ThriftHiveMetastore_drop_partition_result(const ThriftHiveMetastore_drop_partition_result&); + ThriftHiveMetastore_drop_partition_result& operator=(const ThriftHiveMetastore_drop_partition_result&); + ThriftHiveMetastore_drop_partition_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_partition_result() noexcept; + bool success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_drop_partition_result__isset __isset; + + void __set_success(const bool val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_partition_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_partition_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_partition_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_partition_presult__isset { + _ThriftHiveMetastore_drop_partition_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_drop_partition_presult__isset; + +class ThriftHiveMetastore_drop_partition_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_partition_presult() noexcept; + bool* success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_drop_partition_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_partition_with_environment_context_args__isset { + _ThriftHiveMetastore_drop_partition_with_environment_context_args__isset() : db_name(false), tbl_name(false), part_vals(false), deleteData(false), environment_context(false) {} + bool db_name :1; + bool tbl_name :1; + bool part_vals :1; + bool deleteData :1; + bool environment_context :1; +} _ThriftHiveMetastore_drop_partition_with_environment_context_args__isset; + +class ThriftHiveMetastore_drop_partition_with_environment_context_args { + public: + + ThriftHiveMetastore_drop_partition_with_environment_context_args(const ThriftHiveMetastore_drop_partition_with_environment_context_args&); + ThriftHiveMetastore_drop_partition_with_environment_context_args& operator=(const ThriftHiveMetastore_drop_partition_with_environment_context_args&); + ThriftHiveMetastore_drop_partition_with_environment_context_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_partition_with_environment_context_args() noexcept; + std::string db_name; + std::string tbl_name; + std::vector part_vals; + bool deleteData; + EnvironmentContext environment_context; + + _ThriftHiveMetastore_drop_partition_with_environment_context_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_part_vals(const std::vector & val); + + void __set_deleteData(const bool val); + + void __set_environment_context(const EnvironmentContext& val); + + bool operator == (const ThriftHiveMetastore_drop_partition_with_environment_context_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_partition_with_environment_context_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_partition_with_environment_context_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_partition_with_environment_context_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_partition_with_environment_context_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::vector * part_vals; + const bool* deleteData; + const EnvironmentContext* environment_context; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_partition_with_environment_context_result__isset { + _ThriftHiveMetastore_drop_partition_with_environment_context_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_drop_partition_with_environment_context_result__isset; + +class ThriftHiveMetastore_drop_partition_with_environment_context_result { + public: + + ThriftHiveMetastore_drop_partition_with_environment_context_result(const ThriftHiveMetastore_drop_partition_with_environment_context_result&); + ThriftHiveMetastore_drop_partition_with_environment_context_result& operator=(const ThriftHiveMetastore_drop_partition_with_environment_context_result&); + ThriftHiveMetastore_drop_partition_with_environment_context_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_partition_with_environment_context_result() noexcept; + bool success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_drop_partition_with_environment_context_result__isset __isset; + + void __set_success(const bool val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_partition_with_environment_context_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_partition_with_environment_context_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_partition_with_environment_context_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_partition_with_environment_context_presult__isset { + _ThriftHiveMetastore_drop_partition_with_environment_context_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_drop_partition_with_environment_context_presult__isset; + +class ThriftHiveMetastore_drop_partition_with_environment_context_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_partition_with_environment_context_presult() noexcept; + bool* success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_drop_partition_with_environment_context_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_partition_req_args__isset { + _ThriftHiveMetastore_drop_partition_req_args__isset() : dropPartitionReq(false) {} + bool dropPartitionReq :1; +} _ThriftHiveMetastore_drop_partition_req_args__isset; + +class ThriftHiveMetastore_drop_partition_req_args { + public: + + ThriftHiveMetastore_drop_partition_req_args(const ThriftHiveMetastore_drop_partition_req_args&); + ThriftHiveMetastore_drop_partition_req_args& operator=(const ThriftHiveMetastore_drop_partition_req_args&); + ThriftHiveMetastore_drop_partition_req_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_partition_req_args() noexcept; + DropPartitionRequest dropPartitionReq; + + _ThriftHiveMetastore_drop_partition_req_args__isset __isset; + + void __set_dropPartitionReq(const DropPartitionRequest& val); + + bool operator == (const ThriftHiveMetastore_drop_partition_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_partition_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_partition_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_partition_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_partition_req_pargs() noexcept; + const DropPartitionRequest* dropPartitionReq; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_partition_req_result__isset { + _ThriftHiveMetastore_drop_partition_req_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_drop_partition_req_result__isset; + +class ThriftHiveMetastore_drop_partition_req_result { + public: + + ThriftHiveMetastore_drop_partition_req_result(const ThriftHiveMetastore_drop_partition_req_result&); + ThriftHiveMetastore_drop_partition_req_result& operator=(const ThriftHiveMetastore_drop_partition_req_result&); + ThriftHiveMetastore_drop_partition_req_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_partition_req_result() noexcept; + bool success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_drop_partition_req_result__isset __isset; + + void __set_success(const bool val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_partition_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_partition_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_partition_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_partition_req_presult__isset { + _ThriftHiveMetastore_drop_partition_req_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_drop_partition_req_presult__isset; + +class ThriftHiveMetastore_drop_partition_req_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_partition_req_presult() noexcept; + bool* success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_drop_partition_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_partition_by_name_args__isset { + _ThriftHiveMetastore_drop_partition_by_name_args__isset() : db_name(false), tbl_name(false), part_name(false), deleteData(false) {} + bool db_name :1; + bool tbl_name :1; + bool part_name :1; + bool deleteData :1; +} _ThriftHiveMetastore_drop_partition_by_name_args__isset; + +class ThriftHiveMetastore_drop_partition_by_name_args { + public: + + ThriftHiveMetastore_drop_partition_by_name_args(const ThriftHiveMetastore_drop_partition_by_name_args&); + ThriftHiveMetastore_drop_partition_by_name_args& operator=(const ThriftHiveMetastore_drop_partition_by_name_args&); + ThriftHiveMetastore_drop_partition_by_name_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_partition_by_name_args() noexcept; + std::string db_name; + std::string tbl_name; + std::string part_name; + bool deleteData; + + _ThriftHiveMetastore_drop_partition_by_name_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_part_name(const std::string& val); + + void __set_deleteData(const bool val); + + bool operator == (const ThriftHiveMetastore_drop_partition_by_name_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_partition_by_name_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_partition_by_name_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_partition_by_name_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_partition_by_name_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::string* part_name; + const bool* deleteData; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_partition_by_name_result__isset { + _ThriftHiveMetastore_drop_partition_by_name_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_drop_partition_by_name_result__isset; + +class ThriftHiveMetastore_drop_partition_by_name_result { + public: + + ThriftHiveMetastore_drop_partition_by_name_result(const ThriftHiveMetastore_drop_partition_by_name_result&); + ThriftHiveMetastore_drop_partition_by_name_result& operator=(const ThriftHiveMetastore_drop_partition_by_name_result&); + ThriftHiveMetastore_drop_partition_by_name_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_partition_by_name_result() noexcept; + bool success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_drop_partition_by_name_result__isset __isset; + + void __set_success(const bool val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_partition_by_name_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_partition_by_name_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_partition_by_name_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_partition_by_name_presult__isset { + _ThriftHiveMetastore_drop_partition_by_name_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_drop_partition_by_name_presult__isset; + +class ThriftHiveMetastore_drop_partition_by_name_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_partition_by_name_presult() noexcept; + bool* success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_drop_partition_by_name_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args__isset { + _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args__isset() : db_name(false), tbl_name(false), part_name(false), deleteData(false), environment_context(false) {} + bool db_name :1; + bool tbl_name :1; + bool part_name :1; + bool deleteData :1; + bool environment_context :1; +} _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args__isset; + +class ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args { + public: + + ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args(const ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args&); + ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args& operator=(const ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args&); + ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args() noexcept; + std::string db_name; + std::string tbl_name; + std::string part_name; + bool deleteData; + EnvironmentContext environment_context; + + _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_part_name(const std::string& val); + + void __set_deleteData(const bool val); + + void __set_environment_context(const EnvironmentContext& val); + + bool operator == (const ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_partition_by_name_with_environment_context_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_partition_by_name_with_environment_context_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::string* part_name; + const bool* deleteData; + const EnvironmentContext* environment_context; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result__isset { + _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result__isset; + +class ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result { + public: + + ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result(const ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result&); + ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result& operator=(const ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result&); + ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result() noexcept; + bool success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result__isset __isset; + + void __set_success(const bool val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_presult__isset { + _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_presult__isset; + +class ThriftHiveMetastore_drop_partition_by_name_with_environment_context_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_partition_by_name_with_environment_context_presult() noexcept; + bool* success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_partitions_req_args__isset { + _ThriftHiveMetastore_drop_partitions_req_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_drop_partitions_req_args__isset; + +class ThriftHiveMetastore_drop_partitions_req_args { + public: + + ThriftHiveMetastore_drop_partitions_req_args(const ThriftHiveMetastore_drop_partitions_req_args&); + ThriftHiveMetastore_drop_partitions_req_args& operator=(const ThriftHiveMetastore_drop_partitions_req_args&); + ThriftHiveMetastore_drop_partitions_req_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_partitions_req_args() noexcept; + DropPartitionsRequest req; + + _ThriftHiveMetastore_drop_partitions_req_args__isset __isset; + + void __set_req(const DropPartitionsRequest& val); + + bool operator == (const ThriftHiveMetastore_drop_partitions_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_partitions_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_partitions_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_partitions_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_partitions_req_pargs() noexcept; + const DropPartitionsRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_partitions_req_result__isset { + _ThriftHiveMetastore_drop_partitions_req_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_drop_partitions_req_result__isset; + +class ThriftHiveMetastore_drop_partitions_req_result { + public: + + ThriftHiveMetastore_drop_partitions_req_result(const ThriftHiveMetastore_drop_partitions_req_result&); + ThriftHiveMetastore_drop_partitions_req_result& operator=(const ThriftHiveMetastore_drop_partitions_req_result&); + ThriftHiveMetastore_drop_partitions_req_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_partitions_req_result() noexcept; + DropPartitionsResult success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_drop_partitions_req_result__isset __isset; + + void __set_success(const DropPartitionsResult& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_partitions_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_partitions_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_partitions_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_partitions_req_presult__isset { + _ThriftHiveMetastore_drop_partitions_req_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_drop_partitions_req_presult__isset; + +class ThriftHiveMetastore_drop_partitions_req_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_partitions_req_presult() noexcept; + DropPartitionsResult* success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_drop_partitions_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partition_args__isset { + _ThriftHiveMetastore_get_partition_args__isset() : db_name(false), tbl_name(false), part_vals(false) {} + bool db_name :1; + bool tbl_name :1; + bool part_vals :1; +} _ThriftHiveMetastore_get_partition_args__isset; + +class ThriftHiveMetastore_get_partition_args { + public: + + ThriftHiveMetastore_get_partition_args(const ThriftHiveMetastore_get_partition_args&); + ThriftHiveMetastore_get_partition_args& operator=(const ThriftHiveMetastore_get_partition_args&); + ThriftHiveMetastore_get_partition_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partition_args() noexcept; + std::string db_name; + std::string tbl_name; + std::vector part_vals; + + _ThriftHiveMetastore_get_partition_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_part_vals(const std::vector & val); + + bool operator == (const ThriftHiveMetastore_get_partition_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partition_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partition_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partition_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partition_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::vector * part_vals; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partition_result__isset { + _ThriftHiveMetastore_get_partition_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partition_result__isset; + +class ThriftHiveMetastore_get_partition_result { + public: + + ThriftHiveMetastore_get_partition_result(const ThriftHiveMetastore_get_partition_result&); + ThriftHiveMetastore_get_partition_result& operator=(const ThriftHiveMetastore_get_partition_result&); + ThriftHiveMetastore_get_partition_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partition_result() noexcept; + Partition success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partition_result__isset __isset; + + void __set_success(const Partition& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_partition_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partition_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partition_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partition_presult__isset { + _ThriftHiveMetastore_get_partition_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partition_presult__isset; + +class ThriftHiveMetastore_get_partition_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partition_presult() noexcept; + Partition* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partition_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partition_req_args__isset { + _ThriftHiveMetastore_get_partition_req_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_get_partition_req_args__isset; + +class ThriftHiveMetastore_get_partition_req_args { + public: + + ThriftHiveMetastore_get_partition_req_args(const ThriftHiveMetastore_get_partition_req_args&); + ThriftHiveMetastore_get_partition_req_args& operator=(const ThriftHiveMetastore_get_partition_req_args&); + ThriftHiveMetastore_get_partition_req_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partition_req_args() noexcept; + GetPartitionRequest req; + + _ThriftHiveMetastore_get_partition_req_args__isset __isset; + + void __set_req(const GetPartitionRequest& val); + + bool operator == (const ThriftHiveMetastore_get_partition_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partition_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partition_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partition_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partition_req_pargs() noexcept; + const GetPartitionRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partition_req_result__isset { + _ThriftHiveMetastore_get_partition_req_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partition_req_result__isset; + +class ThriftHiveMetastore_get_partition_req_result { + public: + + ThriftHiveMetastore_get_partition_req_result(const ThriftHiveMetastore_get_partition_req_result&); + ThriftHiveMetastore_get_partition_req_result& operator=(const ThriftHiveMetastore_get_partition_req_result&); + ThriftHiveMetastore_get_partition_req_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partition_req_result() noexcept; + GetPartitionResponse success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partition_req_result__isset __isset; + + void __set_success(const GetPartitionResponse& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_partition_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partition_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partition_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partition_req_presult__isset { + _ThriftHiveMetastore_get_partition_req_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partition_req_presult__isset; + +class ThriftHiveMetastore_get_partition_req_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partition_req_presult() noexcept; + GetPartitionResponse* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partition_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_exchange_partition_args__isset { + _ThriftHiveMetastore_exchange_partition_args__isset() : partitionSpecs(false), source_db(false), source_table_name(false), dest_db(false), dest_table_name(false) {} + bool partitionSpecs :1; + bool source_db :1; + bool source_table_name :1; + bool dest_db :1; + bool dest_table_name :1; +} _ThriftHiveMetastore_exchange_partition_args__isset; + +class ThriftHiveMetastore_exchange_partition_args { + public: + + ThriftHiveMetastore_exchange_partition_args(const ThriftHiveMetastore_exchange_partition_args&); + ThriftHiveMetastore_exchange_partition_args& operator=(const ThriftHiveMetastore_exchange_partition_args&); + ThriftHiveMetastore_exchange_partition_args() noexcept; + + virtual ~ThriftHiveMetastore_exchange_partition_args() noexcept; + std::map partitionSpecs; + std::string source_db; + std::string source_table_name; + std::string dest_db; + std::string dest_table_name; + + _ThriftHiveMetastore_exchange_partition_args__isset __isset; + + void __set_partitionSpecs(const std::map & val); + + void __set_source_db(const std::string& val); + + void __set_source_table_name(const std::string& val); + + void __set_dest_db(const std::string& val); + + void __set_dest_table_name(const std::string& val); + + bool operator == (const ThriftHiveMetastore_exchange_partition_args & rhs) const; + bool operator != (const ThriftHiveMetastore_exchange_partition_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_exchange_partition_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_exchange_partition_pargs { + public: + + + virtual ~ThriftHiveMetastore_exchange_partition_pargs() noexcept; + const std::map * partitionSpecs; + const std::string* source_db; + const std::string* source_table_name; + const std::string* dest_db; + const std::string* dest_table_name; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_exchange_partition_result__isset { + _ThriftHiveMetastore_exchange_partition_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_exchange_partition_result__isset; + +class ThriftHiveMetastore_exchange_partition_result { + public: + + ThriftHiveMetastore_exchange_partition_result(const ThriftHiveMetastore_exchange_partition_result&); + ThriftHiveMetastore_exchange_partition_result& operator=(const ThriftHiveMetastore_exchange_partition_result&); + ThriftHiveMetastore_exchange_partition_result() noexcept; + + virtual ~ThriftHiveMetastore_exchange_partition_result() noexcept; + Partition success; + MetaException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_exchange_partition_result__isset __isset; + + void __set_success(const Partition& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + void __set_o3(const InvalidObjectException& val); + + void __set_o4(const InvalidInputException& val); + + bool operator == (const ThriftHiveMetastore_exchange_partition_result & rhs) const; + bool operator != (const ThriftHiveMetastore_exchange_partition_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_exchange_partition_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_exchange_partition_presult__isset { + _ThriftHiveMetastore_exchange_partition_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_exchange_partition_presult__isset; + +class ThriftHiveMetastore_exchange_partition_presult { + public: + + + virtual ~ThriftHiveMetastore_exchange_partition_presult() noexcept; + Partition* success; + MetaException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_exchange_partition_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_exchange_partitions_args__isset { + _ThriftHiveMetastore_exchange_partitions_args__isset() : partitionSpecs(false), source_db(false), source_table_name(false), dest_db(false), dest_table_name(false) {} + bool partitionSpecs :1; + bool source_db :1; + bool source_table_name :1; + bool dest_db :1; + bool dest_table_name :1; +} _ThriftHiveMetastore_exchange_partitions_args__isset; + +class ThriftHiveMetastore_exchange_partitions_args { + public: + + ThriftHiveMetastore_exchange_partitions_args(const ThriftHiveMetastore_exchange_partitions_args&); + ThriftHiveMetastore_exchange_partitions_args& operator=(const ThriftHiveMetastore_exchange_partitions_args&); + ThriftHiveMetastore_exchange_partitions_args() noexcept; + + virtual ~ThriftHiveMetastore_exchange_partitions_args() noexcept; + std::map partitionSpecs; + std::string source_db; + std::string source_table_name; + std::string dest_db; + std::string dest_table_name; + + _ThriftHiveMetastore_exchange_partitions_args__isset __isset; + + void __set_partitionSpecs(const std::map & val); + + void __set_source_db(const std::string& val); + + void __set_source_table_name(const std::string& val); + + void __set_dest_db(const std::string& val); + + void __set_dest_table_name(const std::string& val); + + bool operator == (const ThriftHiveMetastore_exchange_partitions_args & rhs) const; + bool operator != (const ThriftHiveMetastore_exchange_partitions_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_exchange_partitions_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_exchange_partitions_pargs { + public: + + + virtual ~ThriftHiveMetastore_exchange_partitions_pargs() noexcept; + const std::map * partitionSpecs; + const std::string* source_db; + const std::string* source_table_name; + const std::string* dest_db; + const std::string* dest_table_name; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_exchange_partitions_result__isset { + _ThriftHiveMetastore_exchange_partitions_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_exchange_partitions_result__isset; + +class ThriftHiveMetastore_exchange_partitions_result { + public: + + ThriftHiveMetastore_exchange_partitions_result(const ThriftHiveMetastore_exchange_partitions_result&); + ThriftHiveMetastore_exchange_partitions_result& operator=(const ThriftHiveMetastore_exchange_partitions_result&); + ThriftHiveMetastore_exchange_partitions_result() noexcept; + + virtual ~ThriftHiveMetastore_exchange_partitions_result() noexcept; + std::vector success; + MetaException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_exchange_partitions_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + void __set_o3(const InvalidObjectException& val); + + void __set_o4(const InvalidInputException& val); + + bool operator == (const ThriftHiveMetastore_exchange_partitions_result & rhs) const; + bool operator != (const ThriftHiveMetastore_exchange_partitions_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_exchange_partitions_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_exchange_partitions_presult__isset { + _ThriftHiveMetastore_exchange_partitions_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_exchange_partitions_presult__isset; + +class ThriftHiveMetastore_exchange_partitions_presult { + public: + + + virtual ~ThriftHiveMetastore_exchange_partitions_presult() noexcept; + std::vector * success; + MetaException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_exchange_partitions_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partition_with_auth_args__isset { + _ThriftHiveMetastore_get_partition_with_auth_args__isset() : db_name(false), tbl_name(false), part_vals(false), user_name(false), group_names(false) {} + bool db_name :1; + bool tbl_name :1; + bool part_vals :1; + bool user_name :1; + bool group_names :1; +} _ThriftHiveMetastore_get_partition_with_auth_args__isset; + +class ThriftHiveMetastore_get_partition_with_auth_args { + public: + + ThriftHiveMetastore_get_partition_with_auth_args(const ThriftHiveMetastore_get_partition_with_auth_args&); + ThriftHiveMetastore_get_partition_with_auth_args& operator=(const ThriftHiveMetastore_get_partition_with_auth_args&); + ThriftHiveMetastore_get_partition_with_auth_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partition_with_auth_args() noexcept; + std::string db_name; + std::string tbl_name; + std::vector part_vals; + std::string user_name; + std::vector group_names; + + _ThriftHiveMetastore_get_partition_with_auth_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_part_vals(const std::vector & val); + + void __set_user_name(const std::string& val); + + void __set_group_names(const std::vector & val); + + bool operator == (const ThriftHiveMetastore_get_partition_with_auth_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partition_with_auth_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partition_with_auth_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partition_with_auth_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partition_with_auth_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::vector * part_vals; + const std::string* user_name; + const std::vector * group_names; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partition_with_auth_result__isset { + _ThriftHiveMetastore_get_partition_with_auth_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partition_with_auth_result__isset; + +class ThriftHiveMetastore_get_partition_with_auth_result { + public: + + ThriftHiveMetastore_get_partition_with_auth_result(const ThriftHiveMetastore_get_partition_with_auth_result&); + ThriftHiveMetastore_get_partition_with_auth_result& operator=(const ThriftHiveMetastore_get_partition_with_auth_result&); + ThriftHiveMetastore_get_partition_with_auth_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partition_with_auth_result() noexcept; + Partition success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partition_with_auth_result__isset __isset; + + void __set_success(const Partition& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_partition_with_auth_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partition_with_auth_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partition_with_auth_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partition_with_auth_presult__isset { + _ThriftHiveMetastore_get_partition_with_auth_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partition_with_auth_presult__isset; + +class ThriftHiveMetastore_get_partition_with_auth_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partition_with_auth_presult() noexcept; + Partition* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partition_with_auth_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partition_by_name_args__isset { + _ThriftHiveMetastore_get_partition_by_name_args__isset() : db_name(false), tbl_name(false), part_name(false) {} + bool db_name :1; + bool tbl_name :1; + bool part_name :1; +} _ThriftHiveMetastore_get_partition_by_name_args__isset; + +class ThriftHiveMetastore_get_partition_by_name_args { + public: + + ThriftHiveMetastore_get_partition_by_name_args(const ThriftHiveMetastore_get_partition_by_name_args&); + ThriftHiveMetastore_get_partition_by_name_args& operator=(const ThriftHiveMetastore_get_partition_by_name_args&); + ThriftHiveMetastore_get_partition_by_name_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partition_by_name_args() noexcept; + std::string db_name; + std::string tbl_name; + std::string part_name; + + _ThriftHiveMetastore_get_partition_by_name_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_part_name(const std::string& val); + + bool operator == (const ThriftHiveMetastore_get_partition_by_name_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partition_by_name_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partition_by_name_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partition_by_name_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partition_by_name_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::string* part_name; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partition_by_name_result__isset { + _ThriftHiveMetastore_get_partition_by_name_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partition_by_name_result__isset; + +class ThriftHiveMetastore_get_partition_by_name_result { + public: + + ThriftHiveMetastore_get_partition_by_name_result(const ThriftHiveMetastore_get_partition_by_name_result&); + ThriftHiveMetastore_get_partition_by_name_result& operator=(const ThriftHiveMetastore_get_partition_by_name_result&); + ThriftHiveMetastore_get_partition_by_name_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partition_by_name_result() noexcept; + Partition success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partition_by_name_result__isset __isset; + + void __set_success(const Partition& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_partition_by_name_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partition_by_name_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partition_by_name_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partition_by_name_presult__isset { + _ThriftHiveMetastore_get_partition_by_name_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partition_by_name_presult__isset; + +class ThriftHiveMetastore_get_partition_by_name_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partition_by_name_presult() noexcept; + Partition* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partition_by_name_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_args__isset { + _ThriftHiveMetastore_get_partitions_args__isset() : db_name(false), tbl_name(false), max_parts(true) {} + bool db_name :1; + bool tbl_name :1; + bool max_parts :1; +} _ThriftHiveMetastore_get_partitions_args__isset; + +class ThriftHiveMetastore_get_partitions_args { + public: + + ThriftHiveMetastore_get_partitions_args(const ThriftHiveMetastore_get_partitions_args&); + ThriftHiveMetastore_get_partitions_args& operator=(const ThriftHiveMetastore_get_partitions_args&); + ThriftHiveMetastore_get_partitions_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_args() noexcept; + std::string db_name; + std::string tbl_name; + int16_t max_parts; + + _ThriftHiveMetastore_get_partitions_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_max_parts(const int16_t val); + + bool operator == (const ThriftHiveMetastore_get_partitions_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partitions_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const int16_t* max_parts; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_result__isset { + _ThriftHiveMetastore_get_partitions_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_result__isset; + +class ThriftHiveMetastore_get_partitions_result { + public: + + ThriftHiveMetastore_get_partitions_result(const ThriftHiveMetastore_get_partitions_result&); + ThriftHiveMetastore_get_partitions_result& operator=(const ThriftHiveMetastore_get_partitions_result&); + ThriftHiveMetastore_get_partitions_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_result() noexcept; + std::vector success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_partitions_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_partitions_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_presult__isset { + _ThriftHiveMetastore_get_partitions_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_presult__isset; + +class ThriftHiveMetastore_get_partitions_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_presult() noexcept; + std::vector * success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_partitions_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_req_args__isset { + _ThriftHiveMetastore_get_partitions_req_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_get_partitions_req_args__isset; + +class ThriftHiveMetastore_get_partitions_req_args { + public: + + ThriftHiveMetastore_get_partitions_req_args(const ThriftHiveMetastore_get_partitions_req_args&); + ThriftHiveMetastore_get_partitions_req_args& operator=(const ThriftHiveMetastore_get_partitions_req_args&); + ThriftHiveMetastore_get_partitions_req_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_req_args() noexcept; + PartitionsRequest req; + + _ThriftHiveMetastore_get_partitions_req_args__isset __isset; + + void __set_req(const PartitionsRequest& val); + + bool operator == (const ThriftHiveMetastore_get_partitions_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partitions_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_req_pargs() noexcept; + const PartitionsRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_req_result__isset { + _ThriftHiveMetastore_get_partitions_req_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_req_result__isset; + +class ThriftHiveMetastore_get_partitions_req_result { + public: + + ThriftHiveMetastore_get_partitions_req_result(const ThriftHiveMetastore_get_partitions_req_result&); + ThriftHiveMetastore_get_partitions_req_result& operator=(const ThriftHiveMetastore_get_partitions_req_result&); + ThriftHiveMetastore_get_partitions_req_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_req_result() noexcept; + PartitionsResponse success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_partitions_req_result__isset __isset; + + void __set_success(const PartitionsResponse& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_partitions_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_req_presult__isset { + _ThriftHiveMetastore_get_partitions_req_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_req_presult__isset; + +class ThriftHiveMetastore_get_partitions_req_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_req_presult() noexcept; + PartitionsResponse* success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_partitions_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_with_auth_args__isset { + _ThriftHiveMetastore_get_partitions_with_auth_args__isset() : db_name(false), tbl_name(false), max_parts(true), user_name(false), group_names(false) {} + bool db_name :1; + bool tbl_name :1; + bool max_parts :1; + bool user_name :1; + bool group_names :1; +} _ThriftHiveMetastore_get_partitions_with_auth_args__isset; + +class ThriftHiveMetastore_get_partitions_with_auth_args { + public: + + ThriftHiveMetastore_get_partitions_with_auth_args(const ThriftHiveMetastore_get_partitions_with_auth_args&); + ThriftHiveMetastore_get_partitions_with_auth_args& operator=(const ThriftHiveMetastore_get_partitions_with_auth_args&); + ThriftHiveMetastore_get_partitions_with_auth_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_with_auth_args() noexcept; + std::string db_name; + std::string tbl_name; + int16_t max_parts; + std::string user_name; + std::vector group_names; + + _ThriftHiveMetastore_get_partitions_with_auth_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_max_parts(const int16_t val); + + void __set_user_name(const std::string& val); + + void __set_group_names(const std::vector & val); + + bool operator == (const ThriftHiveMetastore_get_partitions_with_auth_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_with_auth_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_with_auth_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partitions_with_auth_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_with_auth_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const int16_t* max_parts; + const std::string* user_name; + const std::vector * group_names; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_with_auth_result__isset { + _ThriftHiveMetastore_get_partitions_with_auth_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_with_auth_result__isset; + +class ThriftHiveMetastore_get_partitions_with_auth_result { + public: + + ThriftHiveMetastore_get_partitions_with_auth_result(const ThriftHiveMetastore_get_partitions_with_auth_result&); + ThriftHiveMetastore_get_partitions_with_auth_result& operator=(const ThriftHiveMetastore_get_partitions_with_auth_result&); + ThriftHiveMetastore_get_partitions_with_auth_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_with_auth_result() noexcept; + std::vector success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_partitions_with_auth_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_partitions_with_auth_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_with_auth_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_with_auth_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_with_auth_presult__isset { + _ThriftHiveMetastore_get_partitions_with_auth_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_with_auth_presult__isset; + +class ThriftHiveMetastore_get_partitions_with_auth_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_with_auth_presult() noexcept; + std::vector * success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_partitions_with_auth_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_pspec_args__isset { + _ThriftHiveMetastore_get_partitions_pspec_args__isset() : db_name(false), tbl_name(false), max_parts(true) {} + bool db_name :1; + bool tbl_name :1; + bool max_parts :1; +} _ThriftHiveMetastore_get_partitions_pspec_args__isset; + +class ThriftHiveMetastore_get_partitions_pspec_args { + public: + + ThriftHiveMetastore_get_partitions_pspec_args(const ThriftHiveMetastore_get_partitions_pspec_args&); + ThriftHiveMetastore_get_partitions_pspec_args& operator=(const ThriftHiveMetastore_get_partitions_pspec_args&); + ThriftHiveMetastore_get_partitions_pspec_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_pspec_args() noexcept; + std::string db_name; + std::string tbl_name; + int32_t max_parts; + + _ThriftHiveMetastore_get_partitions_pspec_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_max_parts(const int32_t val); + + bool operator == (const ThriftHiveMetastore_get_partitions_pspec_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_pspec_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_pspec_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partitions_pspec_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_pspec_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const int32_t* max_parts; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_pspec_result__isset { + _ThriftHiveMetastore_get_partitions_pspec_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_pspec_result__isset; + +class ThriftHiveMetastore_get_partitions_pspec_result { + public: + + ThriftHiveMetastore_get_partitions_pspec_result(const ThriftHiveMetastore_get_partitions_pspec_result&); + ThriftHiveMetastore_get_partitions_pspec_result& operator=(const ThriftHiveMetastore_get_partitions_pspec_result&); + ThriftHiveMetastore_get_partitions_pspec_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_pspec_result() noexcept; + std::vector success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_partitions_pspec_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_partitions_pspec_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_pspec_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_pspec_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_pspec_presult__isset { + _ThriftHiveMetastore_get_partitions_pspec_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_pspec_presult__isset; + +class ThriftHiveMetastore_get_partitions_pspec_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_pspec_presult() noexcept; + std::vector * success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_partitions_pspec_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partition_names_args__isset { + _ThriftHiveMetastore_get_partition_names_args__isset() : db_name(false), tbl_name(false), max_parts(true) {} + bool db_name :1; + bool tbl_name :1; + bool max_parts :1; +} _ThriftHiveMetastore_get_partition_names_args__isset; + +class ThriftHiveMetastore_get_partition_names_args { + public: + + ThriftHiveMetastore_get_partition_names_args(const ThriftHiveMetastore_get_partition_names_args&); + ThriftHiveMetastore_get_partition_names_args& operator=(const ThriftHiveMetastore_get_partition_names_args&); + ThriftHiveMetastore_get_partition_names_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partition_names_args() noexcept; + std::string db_name; + std::string tbl_name; + int16_t max_parts; + + _ThriftHiveMetastore_get_partition_names_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_max_parts(const int16_t val); + + bool operator == (const ThriftHiveMetastore_get_partition_names_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partition_names_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partition_names_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partition_names_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partition_names_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const int16_t* max_parts; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partition_names_result__isset { + _ThriftHiveMetastore_get_partition_names_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partition_names_result__isset; + +class ThriftHiveMetastore_get_partition_names_result { + public: + + ThriftHiveMetastore_get_partition_names_result(const ThriftHiveMetastore_get_partition_names_result&); + ThriftHiveMetastore_get_partition_names_result& operator=(const ThriftHiveMetastore_get_partition_names_result&); + ThriftHiveMetastore_get_partition_names_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partition_names_result() noexcept; + std::vector success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_partition_names_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_partition_names_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partition_names_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partition_names_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partition_names_presult__isset { + _ThriftHiveMetastore_get_partition_names_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partition_names_presult__isset; + +class ThriftHiveMetastore_get_partition_names_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partition_names_presult() noexcept; + std::vector * success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_partition_names_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_fetch_partition_names_req_args__isset { + _ThriftHiveMetastore_fetch_partition_names_req_args__isset() : partitionReq(false) {} + bool partitionReq :1; +} _ThriftHiveMetastore_fetch_partition_names_req_args__isset; + +class ThriftHiveMetastore_fetch_partition_names_req_args { + public: + + ThriftHiveMetastore_fetch_partition_names_req_args(const ThriftHiveMetastore_fetch_partition_names_req_args&); + ThriftHiveMetastore_fetch_partition_names_req_args& operator=(const ThriftHiveMetastore_fetch_partition_names_req_args&); + ThriftHiveMetastore_fetch_partition_names_req_args() noexcept; + + virtual ~ThriftHiveMetastore_fetch_partition_names_req_args() noexcept; + PartitionsRequest partitionReq; + + _ThriftHiveMetastore_fetch_partition_names_req_args__isset __isset; + + void __set_partitionReq(const PartitionsRequest& val); + + bool operator == (const ThriftHiveMetastore_fetch_partition_names_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_fetch_partition_names_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_fetch_partition_names_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_fetch_partition_names_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_fetch_partition_names_req_pargs() noexcept; + const PartitionsRequest* partitionReq; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_fetch_partition_names_req_result__isset { + _ThriftHiveMetastore_fetch_partition_names_req_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_fetch_partition_names_req_result__isset; + +class ThriftHiveMetastore_fetch_partition_names_req_result { + public: + + ThriftHiveMetastore_fetch_partition_names_req_result(const ThriftHiveMetastore_fetch_partition_names_req_result&); + ThriftHiveMetastore_fetch_partition_names_req_result& operator=(const ThriftHiveMetastore_fetch_partition_names_req_result&); + ThriftHiveMetastore_fetch_partition_names_req_result() noexcept; + + virtual ~ThriftHiveMetastore_fetch_partition_names_req_result() noexcept; + std::vector success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_fetch_partition_names_req_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_fetch_partition_names_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_fetch_partition_names_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_fetch_partition_names_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_fetch_partition_names_req_presult__isset { + _ThriftHiveMetastore_fetch_partition_names_req_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_fetch_partition_names_req_presult__isset; + +class ThriftHiveMetastore_fetch_partition_names_req_presult { + public: + + + virtual ~ThriftHiveMetastore_fetch_partition_names_req_presult() noexcept; + std::vector * success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_fetch_partition_names_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partition_values_args__isset { + _ThriftHiveMetastore_get_partition_values_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_partition_values_args__isset; + +class ThriftHiveMetastore_get_partition_values_args { + public: + + ThriftHiveMetastore_get_partition_values_args(const ThriftHiveMetastore_get_partition_values_args&); + ThriftHiveMetastore_get_partition_values_args& operator=(const ThriftHiveMetastore_get_partition_values_args&); + ThriftHiveMetastore_get_partition_values_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partition_values_args() noexcept; + PartitionValuesRequest request; + + _ThriftHiveMetastore_get_partition_values_args__isset __isset; + + void __set_request(const PartitionValuesRequest& val); + + bool operator == (const ThriftHiveMetastore_get_partition_values_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partition_values_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partition_values_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partition_values_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partition_values_pargs() noexcept; + const PartitionValuesRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partition_values_result__isset { + _ThriftHiveMetastore_get_partition_values_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partition_values_result__isset; + +class ThriftHiveMetastore_get_partition_values_result { + public: + + ThriftHiveMetastore_get_partition_values_result(const ThriftHiveMetastore_get_partition_values_result&); + ThriftHiveMetastore_get_partition_values_result& operator=(const ThriftHiveMetastore_get_partition_values_result&); + ThriftHiveMetastore_get_partition_values_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partition_values_result() noexcept; + PartitionValuesResponse success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partition_values_result__isset __isset; + + void __set_success(const PartitionValuesResponse& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_partition_values_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partition_values_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partition_values_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partition_values_presult__isset { + _ThriftHiveMetastore_get_partition_values_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partition_values_presult__isset; + +class ThriftHiveMetastore_get_partition_values_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partition_values_presult() noexcept; + PartitionValuesResponse* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partition_values_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_ps_args__isset { + _ThriftHiveMetastore_get_partitions_ps_args__isset() : db_name(false), tbl_name(false), part_vals(false), max_parts(true) {} + bool db_name :1; + bool tbl_name :1; + bool part_vals :1; + bool max_parts :1; +} _ThriftHiveMetastore_get_partitions_ps_args__isset; + +class ThriftHiveMetastore_get_partitions_ps_args { + public: + + ThriftHiveMetastore_get_partitions_ps_args(const ThriftHiveMetastore_get_partitions_ps_args&); + ThriftHiveMetastore_get_partitions_ps_args& operator=(const ThriftHiveMetastore_get_partitions_ps_args&); + ThriftHiveMetastore_get_partitions_ps_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_ps_args() noexcept; + std::string db_name; + std::string tbl_name; + std::vector part_vals; + int16_t max_parts; + + _ThriftHiveMetastore_get_partitions_ps_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_part_vals(const std::vector & val); + + void __set_max_parts(const int16_t val); + + bool operator == (const ThriftHiveMetastore_get_partitions_ps_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_ps_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_ps_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partitions_ps_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_ps_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::vector * part_vals; + const int16_t* max_parts; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_ps_result__isset { + _ThriftHiveMetastore_get_partitions_ps_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_ps_result__isset; + +class ThriftHiveMetastore_get_partitions_ps_result { + public: + + ThriftHiveMetastore_get_partitions_ps_result(const ThriftHiveMetastore_get_partitions_ps_result&); + ThriftHiveMetastore_get_partitions_ps_result& operator=(const ThriftHiveMetastore_get_partitions_ps_result&); + ThriftHiveMetastore_get_partitions_ps_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_ps_result() noexcept; + std::vector success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partitions_ps_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_partitions_ps_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_ps_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_ps_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_ps_presult__isset { + _ThriftHiveMetastore_get_partitions_ps_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_ps_presult__isset; + +class ThriftHiveMetastore_get_partitions_ps_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_ps_presult() noexcept; + std::vector * success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partitions_ps_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_ps_with_auth_args__isset { + _ThriftHiveMetastore_get_partitions_ps_with_auth_args__isset() : db_name(false), tbl_name(false), part_vals(false), max_parts(true), user_name(false), group_names(false) {} + bool db_name :1; + bool tbl_name :1; + bool part_vals :1; + bool max_parts :1; + bool user_name :1; + bool group_names :1; +} _ThriftHiveMetastore_get_partitions_ps_with_auth_args__isset; + +class ThriftHiveMetastore_get_partitions_ps_with_auth_args { + public: + + ThriftHiveMetastore_get_partitions_ps_with_auth_args(const ThriftHiveMetastore_get_partitions_ps_with_auth_args&); + ThriftHiveMetastore_get_partitions_ps_with_auth_args& operator=(const ThriftHiveMetastore_get_partitions_ps_with_auth_args&); + ThriftHiveMetastore_get_partitions_ps_with_auth_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_ps_with_auth_args() noexcept; + std::string db_name; + std::string tbl_name; + std::vector part_vals; + int16_t max_parts; + std::string user_name; + std::vector group_names; + + _ThriftHiveMetastore_get_partitions_ps_with_auth_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_part_vals(const std::vector & val); + + void __set_max_parts(const int16_t val); + + void __set_user_name(const std::string& val); + + void __set_group_names(const std::vector & val); + + bool operator == (const ThriftHiveMetastore_get_partitions_ps_with_auth_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_ps_with_auth_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_ps_with_auth_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partitions_ps_with_auth_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_ps_with_auth_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::vector * part_vals; + const int16_t* max_parts; + const std::string* user_name; + const std::vector * group_names; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_ps_with_auth_result__isset { + _ThriftHiveMetastore_get_partitions_ps_with_auth_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_ps_with_auth_result__isset; + +class ThriftHiveMetastore_get_partitions_ps_with_auth_result { + public: + + ThriftHiveMetastore_get_partitions_ps_with_auth_result(const ThriftHiveMetastore_get_partitions_ps_with_auth_result&); + ThriftHiveMetastore_get_partitions_ps_with_auth_result& operator=(const ThriftHiveMetastore_get_partitions_ps_with_auth_result&); + ThriftHiveMetastore_get_partitions_ps_with_auth_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_ps_with_auth_result() noexcept; + std::vector success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_partitions_ps_with_auth_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_partitions_ps_with_auth_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_ps_with_auth_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_ps_with_auth_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_ps_with_auth_presult__isset { + _ThriftHiveMetastore_get_partitions_ps_with_auth_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_ps_with_auth_presult__isset; + +class ThriftHiveMetastore_get_partitions_ps_with_auth_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_ps_with_auth_presult() noexcept; + std::vector * success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_partitions_ps_with_auth_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_ps_with_auth_req_args__isset { + _ThriftHiveMetastore_get_partitions_ps_with_auth_req_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_get_partitions_ps_with_auth_req_args__isset; + +class ThriftHiveMetastore_get_partitions_ps_with_auth_req_args { + public: + + ThriftHiveMetastore_get_partitions_ps_with_auth_req_args(const ThriftHiveMetastore_get_partitions_ps_with_auth_req_args&); + ThriftHiveMetastore_get_partitions_ps_with_auth_req_args& operator=(const ThriftHiveMetastore_get_partitions_ps_with_auth_req_args&); + ThriftHiveMetastore_get_partitions_ps_with_auth_req_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_ps_with_auth_req_args() noexcept; + GetPartitionsPsWithAuthRequest req; + + _ThriftHiveMetastore_get_partitions_ps_with_auth_req_args__isset __isset; + + void __set_req(const GetPartitionsPsWithAuthRequest& val); + + bool operator == (const ThriftHiveMetastore_get_partitions_ps_with_auth_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_ps_with_auth_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_ps_with_auth_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partitions_ps_with_auth_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_ps_with_auth_req_pargs() noexcept; + const GetPartitionsPsWithAuthRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_ps_with_auth_req_result__isset { + _ThriftHiveMetastore_get_partitions_ps_with_auth_req_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_ps_with_auth_req_result__isset; + +class ThriftHiveMetastore_get_partitions_ps_with_auth_req_result { + public: + + ThriftHiveMetastore_get_partitions_ps_with_auth_req_result(const ThriftHiveMetastore_get_partitions_ps_with_auth_req_result&); + ThriftHiveMetastore_get_partitions_ps_with_auth_req_result& operator=(const ThriftHiveMetastore_get_partitions_ps_with_auth_req_result&); + ThriftHiveMetastore_get_partitions_ps_with_auth_req_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_ps_with_auth_req_result() noexcept; + GetPartitionsPsWithAuthResponse success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partitions_ps_with_auth_req_result__isset __isset; + + void __set_success(const GetPartitionsPsWithAuthResponse& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_partitions_ps_with_auth_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_ps_with_auth_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_ps_with_auth_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_ps_with_auth_req_presult__isset { + _ThriftHiveMetastore_get_partitions_ps_with_auth_req_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_ps_with_auth_req_presult__isset; + +class ThriftHiveMetastore_get_partitions_ps_with_auth_req_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_ps_with_auth_req_presult() noexcept; + GetPartitionsPsWithAuthResponse* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partitions_ps_with_auth_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partition_names_ps_args__isset { + _ThriftHiveMetastore_get_partition_names_ps_args__isset() : db_name(false), tbl_name(false), part_vals(false), max_parts(true) {} + bool db_name :1; + bool tbl_name :1; + bool part_vals :1; + bool max_parts :1; +} _ThriftHiveMetastore_get_partition_names_ps_args__isset; + +class ThriftHiveMetastore_get_partition_names_ps_args { + public: + + ThriftHiveMetastore_get_partition_names_ps_args(const ThriftHiveMetastore_get_partition_names_ps_args&); + ThriftHiveMetastore_get_partition_names_ps_args& operator=(const ThriftHiveMetastore_get_partition_names_ps_args&); + ThriftHiveMetastore_get_partition_names_ps_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partition_names_ps_args() noexcept; + std::string db_name; + std::string tbl_name; + std::vector part_vals; + int16_t max_parts; + + _ThriftHiveMetastore_get_partition_names_ps_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_part_vals(const std::vector & val); + + void __set_max_parts(const int16_t val); + + bool operator == (const ThriftHiveMetastore_get_partition_names_ps_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partition_names_ps_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partition_names_ps_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partition_names_ps_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partition_names_ps_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::vector * part_vals; + const int16_t* max_parts; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partition_names_ps_result__isset { + _ThriftHiveMetastore_get_partition_names_ps_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partition_names_ps_result__isset; + +class ThriftHiveMetastore_get_partition_names_ps_result { + public: + + ThriftHiveMetastore_get_partition_names_ps_result(const ThriftHiveMetastore_get_partition_names_ps_result&); + ThriftHiveMetastore_get_partition_names_ps_result& operator=(const ThriftHiveMetastore_get_partition_names_ps_result&); + ThriftHiveMetastore_get_partition_names_ps_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partition_names_ps_result() noexcept; + std::vector success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partition_names_ps_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_partition_names_ps_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partition_names_ps_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partition_names_ps_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partition_names_ps_presult__isset { + _ThriftHiveMetastore_get_partition_names_ps_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partition_names_ps_presult__isset; + +class ThriftHiveMetastore_get_partition_names_ps_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partition_names_ps_presult() noexcept; + std::vector * success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partition_names_ps_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partition_names_ps_req_args__isset { + _ThriftHiveMetastore_get_partition_names_ps_req_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_get_partition_names_ps_req_args__isset; + +class ThriftHiveMetastore_get_partition_names_ps_req_args { + public: + + ThriftHiveMetastore_get_partition_names_ps_req_args(const ThriftHiveMetastore_get_partition_names_ps_req_args&); + ThriftHiveMetastore_get_partition_names_ps_req_args& operator=(const ThriftHiveMetastore_get_partition_names_ps_req_args&); + ThriftHiveMetastore_get_partition_names_ps_req_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partition_names_ps_req_args() noexcept; + GetPartitionNamesPsRequest req; + + _ThriftHiveMetastore_get_partition_names_ps_req_args__isset __isset; + + void __set_req(const GetPartitionNamesPsRequest& val); + + bool operator == (const ThriftHiveMetastore_get_partition_names_ps_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partition_names_ps_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partition_names_ps_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partition_names_ps_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partition_names_ps_req_pargs() noexcept; + const GetPartitionNamesPsRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partition_names_ps_req_result__isset { + _ThriftHiveMetastore_get_partition_names_ps_req_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partition_names_ps_req_result__isset; + +class ThriftHiveMetastore_get_partition_names_ps_req_result { + public: + + ThriftHiveMetastore_get_partition_names_ps_req_result(const ThriftHiveMetastore_get_partition_names_ps_req_result&); + ThriftHiveMetastore_get_partition_names_ps_req_result& operator=(const ThriftHiveMetastore_get_partition_names_ps_req_result&); + ThriftHiveMetastore_get_partition_names_ps_req_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partition_names_ps_req_result() noexcept; + GetPartitionNamesPsResponse success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partition_names_ps_req_result__isset __isset; + + void __set_success(const GetPartitionNamesPsResponse& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_partition_names_ps_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partition_names_ps_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partition_names_ps_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partition_names_ps_req_presult__isset { + _ThriftHiveMetastore_get_partition_names_ps_req_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partition_names_ps_req_presult__isset; + +class ThriftHiveMetastore_get_partition_names_ps_req_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partition_names_ps_req_presult() noexcept; + GetPartitionNamesPsResponse* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partition_names_ps_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partition_names_req_args__isset { + _ThriftHiveMetastore_get_partition_names_req_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_get_partition_names_req_args__isset; + +class ThriftHiveMetastore_get_partition_names_req_args { + public: + + ThriftHiveMetastore_get_partition_names_req_args(const ThriftHiveMetastore_get_partition_names_req_args&); + ThriftHiveMetastore_get_partition_names_req_args& operator=(const ThriftHiveMetastore_get_partition_names_req_args&); + ThriftHiveMetastore_get_partition_names_req_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partition_names_req_args() noexcept; + PartitionsByExprRequest req; + + _ThriftHiveMetastore_get_partition_names_req_args__isset __isset; + + void __set_req(const PartitionsByExprRequest& val); + + bool operator == (const ThriftHiveMetastore_get_partition_names_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partition_names_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partition_names_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partition_names_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partition_names_req_pargs() noexcept; + const PartitionsByExprRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partition_names_req_result__isset { + _ThriftHiveMetastore_get_partition_names_req_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partition_names_req_result__isset; + +class ThriftHiveMetastore_get_partition_names_req_result { + public: + + ThriftHiveMetastore_get_partition_names_req_result(const ThriftHiveMetastore_get_partition_names_req_result&); + ThriftHiveMetastore_get_partition_names_req_result& operator=(const ThriftHiveMetastore_get_partition_names_req_result&); + ThriftHiveMetastore_get_partition_names_req_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partition_names_req_result() noexcept; + std::vector success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partition_names_req_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_partition_names_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partition_names_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partition_names_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partition_names_req_presult__isset { + _ThriftHiveMetastore_get_partition_names_req_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partition_names_req_presult__isset; + +class ThriftHiveMetastore_get_partition_names_req_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partition_names_req_presult() noexcept; + std::vector * success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partition_names_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_by_filter_args__isset { + _ThriftHiveMetastore_get_partitions_by_filter_args__isset() : db_name(false), tbl_name(false), filter(false), max_parts(true) {} + bool db_name :1; + bool tbl_name :1; + bool filter :1; + bool max_parts :1; +} _ThriftHiveMetastore_get_partitions_by_filter_args__isset; + +class ThriftHiveMetastore_get_partitions_by_filter_args { + public: + + ThriftHiveMetastore_get_partitions_by_filter_args(const ThriftHiveMetastore_get_partitions_by_filter_args&); + ThriftHiveMetastore_get_partitions_by_filter_args& operator=(const ThriftHiveMetastore_get_partitions_by_filter_args&); + ThriftHiveMetastore_get_partitions_by_filter_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_by_filter_args() noexcept; + std::string db_name; + std::string tbl_name; + std::string filter; + int16_t max_parts; + + _ThriftHiveMetastore_get_partitions_by_filter_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_filter(const std::string& val); + + void __set_max_parts(const int16_t val); + + bool operator == (const ThriftHiveMetastore_get_partitions_by_filter_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_by_filter_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_by_filter_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partitions_by_filter_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_by_filter_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::string* filter; + const int16_t* max_parts; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_by_filter_result__isset { + _ThriftHiveMetastore_get_partitions_by_filter_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_by_filter_result__isset; + +class ThriftHiveMetastore_get_partitions_by_filter_result { + public: + + ThriftHiveMetastore_get_partitions_by_filter_result(const ThriftHiveMetastore_get_partitions_by_filter_result&); + ThriftHiveMetastore_get_partitions_by_filter_result& operator=(const ThriftHiveMetastore_get_partitions_by_filter_result&); + ThriftHiveMetastore_get_partitions_by_filter_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_by_filter_result() noexcept; + std::vector success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partitions_by_filter_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_partitions_by_filter_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_by_filter_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_by_filter_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_by_filter_presult__isset { + _ThriftHiveMetastore_get_partitions_by_filter_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_by_filter_presult__isset; + +class ThriftHiveMetastore_get_partitions_by_filter_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_by_filter_presult() noexcept; + std::vector * success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partitions_by_filter_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_by_filter_req_args__isset { + _ThriftHiveMetastore_get_partitions_by_filter_req_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_get_partitions_by_filter_req_args__isset; + +class ThriftHiveMetastore_get_partitions_by_filter_req_args { + public: + + ThriftHiveMetastore_get_partitions_by_filter_req_args(const ThriftHiveMetastore_get_partitions_by_filter_req_args&); + ThriftHiveMetastore_get_partitions_by_filter_req_args& operator=(const ThriftHiveMetastore_get_partitions_by_filter_req_args&); + ThriftHiveMetastore_get_partitions_by_filter_req_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_by_filter_req_args() noexcept; + GetPartitionsByFilterRequest req; + + _ThriftHiveMetastore_get_partitions_by_filter_req_args__isset __isset; + + void __set_req(const GetPartitionsByFilterRequest& val); + + bool operator == (const ThriftHiveMetastore_get_partitions_by_filter_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_by_filter_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_by_filter_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partitions_by_filter_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_by_filter_req_pargs() noexcept; + const GetPartitionsByFilterRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_by_filter_req_result__isset { + _ThriftHiveMetastore_get_partitions_by_filter_req_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_by_filter_req_result__isset; + +class ThriftHiveMetastore_get_partitions_by_filter_req_result { + public: + + ThriftHiveMetastore_get_partitions_by_filter_req_result(const ThriftHiveMetastore_get_partitions_by_filter_req_result&); + ThriftHiveMetastore_get_partitions_by_filter_req_result& operator=(const ThriftHiveMetastore_get_partitions_by_filter_req_result&); + ThriftHiveMetastore_get_partitions_by_filter_req_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_by_filter_req_result() noexcept; + std::vector success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partitions_by_filter_req_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_partitions_by_filter_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_by_filter_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_by_filter_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_by_filter_req_presult__isset { + _ThriftHiveMetastore_get_partitions_by_filter_req_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_by_filter_req_presult__isset; + +class ThriftHiveMetastore_get_partitions_by_filter_req_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_by_filter_req_presult() noexcept; + std::vector * success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partitions_by_filter_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_part_specs_by_filter_args__isset { + _ThriftHiveMetastore_get_part_specs_by_filter_args__isset() : db_name(false), tbl_name(false), filter(false), max_parts(true) {} + bool db_name :1; + bool tbl_name :1; + bool filter :1; + bool max_parts :1; +} _ThriftHiveMetastore_get_part_specs_by_filter_args__isset; + +class ThriftHiveMetastore_get_part_specs_by_filter_args { + public: + + ThriftHiveMetastore_get_part_specs_by_filter_args(const ThriftHiveMetastore_get_part_specs_by_filter_args&); + ThriftHiveMetastore_get_part_specs_by_filter_args& operator=(const ThriftHiveMetastore_get_part_specs_by_filter_args&); + ThriftHiveMetastore_get_part_specs_by_filter_args() noexcept; + + virtual ~ThriftHiveMetastore_get_part_specs_by_filter_args() noexcept; + std::string db_name; + std::string tbl_name; + std::string filter; + int32_t max_parts; + + _ThriftHiveMetastore_get_part_specs_by_filter_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_filter(const std::string& val); + + void __set_max_parts(const int32_t val); + + bool operator == (const ThriftHiveMetastore_get_part_specs_by_filter_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_part_specs_by_filter_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_part_specs_by_filter_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_part_specs_by_filter_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_part_specs_by_filter_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::string* filter; + const int32_t* max_parts; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_part_specs_by_filter_result__isset { + _ThriftHiveMetastore_get_part_specs_by_filter_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_part_specs_by_filter_result__isset; + +class ThriftHiveMetastore_get_part_specs_by_filter_result { + public: + + ThriftHiveMetastore_get_part_specs_by_filter_result(const ThriftHiveMetastore_get_part_specs_by_filter_result&); + ThriftHiveMetastore_get_part_specs_by_filter_result& operator=(const ThriftHiveMetastore_get_part_specs_by_filter_result&); + ThriftHiveMetastore_get_part_specs_by_filter_result() noexcept; + + virtual ~ThriftHiveMetastore_get_part_specs_by_filter_result() noexcept; + std::vector success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_part_specs_by_filter_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_part_specs_by_filter_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_part_specs_by_filter_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_part_specs_by_filter_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_part_specs_by_filter_presult__isset { + _ThriftHiveMetastore_get_part_specs_by_filter_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_part_specs_by_filter_presult__isset; + +class ThriftHiveMetastore_get_part_specs_by_filter_presult { + public: + + + virtual ~ThriftHiveMetastore_get_part_specs_by_filter_presult() noexcept; + std::vector * success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_part_specs_by_filter_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_by_expr_args__isset { + _ThriftHiveMetastore_get_partitions_by_expr_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_get_partitions_by_expr_args__isset; + +class ThriftHiveMetastore_get_partitions_by_expr_args { + public: + + ThriftHiveMetastore_get_partitions_by_expr_args(const ThriftHiveMetastore_get_partitions_by_expr_args&); + ThriftHiveMetastore_get_partitions_by_expr_args& operator=(const ThriftHiveMetastore_get_partitions_by_expr_args&); + ThriftHiveMetastore_get_partitions_by_expr_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_by_expr_args() noexcept; + PartitionsByExprRequest req; + + _ThriftHiveMetastore_get_partitions_by_expr_args__isset __isset; + + void __set_req(const PartitionsByExprRequest& val); + + bool operator == (const ThriftHiveMetastore_get_partitions_by_expr_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_by_expr_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_by_expr_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partitions_by_expr_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_by_expr_pargs() noexcept; + const PartitionsByExprRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_by_expr_result__isset { + _ThriftHiveMetastore_get_partitions_by_expr_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_by_expr_result__isset; + +class ThriftHiveMetastore_get_partitions_by_expr_result { + public: + + ThriftHiveMetastore_get_partitions_by_expr_result(const ThriftHiveMetastore_get_partitions_by_expr_result&); + ThriftHiveMetastore_get_partitions_by_expr_result& operator=(const ThriftHiveMetastore_get_partitions_by_expr_result&); + ThriftHiveMetastore_get_partitions_by_expr_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_by_expr_result() noexcept; + PartitionsByExprResult success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partitions_by_expr_result__isset __isset; + + void __set_success(const PartitionsByExprResult& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_partitions_by_expr_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_by_expr_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_by_expr_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_by_expr_presult__isset { + _ThriftHiveMetastore_get_partitions_by_expr_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_by_expr_presult__isset; + +class ThriftHiveMetastore_get_partitions_by_expr_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_by_expr_presult() noexcept; + PartitionsByExprResult* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partitions_by_expr_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_spec_by_expr_args__isset { + _ThriftHiveMetastore_get_partitions_spec_by_expr_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_get_partitions_spec_by_expr_args__isset; + +class ThriftHiveMetastore_get_partitions_spec_by_expr_args { + public: + + ThriftHiveMetastore_get_partitions_spec_by_expr_args(const ThriftHiveMetastore_get_partitions_spec_by_expr_args&); + ThriftHiveMetastore_get_partitions_spec_by_expr_args& operator=(const ThriftHiveMetastore_get_partitions_spec_by_expr_args&); + ThriftHiveMetastore_get_partitions_spec_by_expr_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_spec_by_expr_args() noexcept; + PartitionsByExprRequest req; + + _ThriftHiveMetastore_get_partitions_spec_by_expr_args__isset __isset; + + void __set_req(const PartitionsByExprRequest& val); + + bool operator == (const ThriftHiveMetastore_get_partitions_spec_by_expr_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_spec_by_expr_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_spec_by_expr_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partitions_spec_by_expr_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_spec_by_expr_pargs() noexcept; + const PartitionsByExprRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_spec_by_expr_result__isset { + _ThriftHiveMetastore_get_partitions_spec_by_expr_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_spec_by_expr_result__isset; + +class ThriftHiveMetastore_get_partitions_spec_by_expr_result { + public: + + ThriftHiveMetastore_get_partitions_spec_by_expr_result(const ThriftHiveMetastore_get_partitions_spec_by_expr_result&); + ThriftHiveMetastore_get_partitions_spec_by_expr_result& operator=(const ThriftHiveMetastore_get_partitions_spec_by_expr_result&); + ThriftHiveMetastore_get_partitions_spec_by_expr_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_spec_by_expr_result() noexcept; + PartitionsSpecByExprResult success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partitions_spec_by_expr_result__isset __isset; + + void __set_success(const PartitionsSpecByExprResult& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_partitions_spec_by_expr_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_spec_by_expr_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_spec_by_expr_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_spec_by_expr_presult__isset { + _ThriftHiveMetastore_get_partitions_spec_by_expr_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_spec_by_expr_presult__isset; + +class ThriftHiveMetastore_get_partitions_spec_by_expr_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_spec_by_expr_presult() noexcept; + PartitionsSpecByExprResult* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_partitions_spec_by_expr_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_num_partitions_by_filter_args__isset { + _ThriftHiveMetastore_get_num_partitions_by_filter_args__isset() : db_name(false), tbl_name(false), filter(false) {} + bool db_name :1; + bool tbl_name :1; + bool filter :1; +} _ThriftHiveMetastore_get_num_partitions_by_filter_args__isset; + +class ThriftHiveMetastore_get_num_partitions_by_filter_args { + public: + + ThriftHiveMetastore_get_num_partitions_by_filter_args(const ThriftHiveMetastore_get_num_partitions_by_filter_args&); + ThriftHiveMetastore_get_num_partitions_by_filter_args& operator=(const ThriftHiveMetastore_get_num_partitions_by_filter_args&); + ThriftHiveMetastore_get_num_partitions_by_filter_args() noexcept; + + virtual ~ThriftHiveMetastore_get_num_partitions_by_filter_args() noexcept; + std::string db_name; + std::string tbl_name; + std::string filter; + + _ThriftHiveMetastore_get_num_partitions_by_filter_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_filter(const std::string& val); + + bool operator == (const ThriftHiveMetastore_get_num_partitions_by_filter_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_num_partitions_by_filter_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_num_partitions_by_filter_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_num_partitions_by_filter_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_num_partitions_by_filter_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::string* filter; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_num_partitions_by_filter_result__isset { + _ThriftHiveMetastore_get_num_partitions_by_filter_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_num_partitions_by_filter_result__isset; + +class ThriftHiveMetastore_get_num_partitions_by_filter_result { + public: + + ThriftHiveMetastore_get_num_partitions_by_filter_result(const ThriftHiveMetastore_get_num_partitions_by_filter_result&); + ThriftHiveMetastore_get_num_partitions_by_filter_result& operator=(const ThriftHiveMetastore_get_num_partitions_by_filter_result&); + ThriftHiveMetastore_get_num_partitions_by_filter_result() noexcept; + + virtual ~ThriftHiveMetastore_get_num_partitions_by_filter_result() noexcept; + int32_t success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_num_partitions_by_filter_result__isset __isset; + + void __set_success(const int32_t val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_num_partitions_by_filter_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_num_partitions_by_filter_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_num_partitions_by_filter_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_num_partitions_by_filter_presult__isset { + _ThriftHiveMetastore_get_num_partitions_by_filter_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_num_partitions_by_filter_presult__isset; + +class ThriftHiveMetastore_get_num_partitions_by_filter_presult { + public: + + + virtual ~ThriftHiveMetastore_get_num_partitions_by_filter_presult() noexcept; + int32_t* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_num_partitions_by_filter_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_by_names_args__isset { + _ThriftHiveMetastore_get_partitions_by_names_args__isset() : db_name(false), tbl_name(false), names(false) {} + bool db_name :1; + bool tbl_name :1; + bool names :1; +} _ThriftHiveMetastore_get_partitions_by_names_args__isset; + +class ThriftHiveMetastore_get_partitions_by_names_args { + public: + + ThriftHiveMetastore_get_partitions_by_names_args(const ThriftHiveMetastore_get_partitions_by_names_args&); + ThriftHiveMetastore_get_partitions_by_names_args& operator=(const ThriftHiveMetastore_get_partitions_by_names_args&); + ThriftHiveMetastore_get_partitions_by_names_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_by_names_args() noexcept; + std::string db_name; + std::string tbl_name; + std::vector names; + + _ThriftHiveMetastore_get_partitions_by_names_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_names(const std::vector & val); + + bool operator == (const ThriftHiveMetastore_get_partitions_by_names_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_by_names_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_by_names_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partitions_by_names_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_by_names_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::vector * names; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_by_names_result__isset { + _ThriftHiveMetastore_get_partitions_by_names_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_get_partitions_by_names_result__isset; + +class ThriftHiveMetastore_get_partitions_by_names_result { + public: + + ThriftHiveMetastore_get_partitions_by_names_result(const ThriftHiveMetastore_get_partitions_by_names_result&); + ThriftHiveMetastore_get_partitions_by_names_result& operator=(const ThriftHiveMetastore_get_partitions_by_names_result&); + ThriftHiveMetastore_get_partitions_by_names_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_by_names_result() noexcept; + std::vector success; + MetaException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + + _ThriftHiveMetastore_get_partitions_by_names_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + void __set_o3(const InvalidObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_partitions_by_names_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_by_names_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_by_names_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_by_names_presult__isset { + _ThriftHiveMetastore_get_partitions_by_names_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_get_partitions_by_names_presult__isset; + +class ThriftHiveMetastore_get_partitions_by_names_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_by_names_presult() noexcept; + std::vector * success; + MetaException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + + _ThriftHiveMetastore_get_partitions_by_names_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_by_names_req_args__isset { + _ThriftHiveMetastore_get_partitions_by_names_req_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_get_partitions_by_names_req_args__isset; + +class ThriftHiveMetastore_get_partitions_by_names_req_args { + public: + + ThriftHiveMetastore_get_partitions_by_names_req_args(const ThriftHiveMetastore_get_partitions_by_names_req_args&); + ThriftHiveMetastore_get_partitions_by_names_req_args& operator=(const ThriftHiveMetastore_get_partitions_by_names_req_args&); + ThriftHiveMetastore_get_partitions_by_names_req_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_by_names_req_args() noexcept; + GetPartitionsByNamesRequest req; + + _ThriftHiveMetastore_get_partitions_by_names_req_args__isset __isset; + + void __set_req(const GetPartitionsByNamesRequest& val); + + bool operator == (const ThriftHiveMetastore_get_partitions_by_names_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_by_names_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_by_names_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partitions_by_names_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_by_names_req_pargs() noexcept; + const GetPartitionsByNamesRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_by_names_req_result__isset { + _ThriftHiveMetastore_get_partitions_by_names_req_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_get_partitions_by_names_req_result__isset; + +class ThriftHiveMetastore_get_partitions_by_names_req_result { + public: + + ThriftHiveMetastore_get_partitions_by_names_req_result(const ThriftHiveMetastore_get_partitions_by_names_req_result&); + ThriftHiveMetastore_get_partitions_by_names_req_result& operator=(const ThriftHiveMetastore_get_partitions_by_names_req_result&); + ThriftHiveMetastore_get_partitions_by_names_req_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_by_names_req_result() noexcept; + GetPartitionsByNamesResult success; + MetaException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + + _ThriftHiveMetastore_get_partitions_by_names_req_result__isset __isset; + + void __set_success(const GetPartitionsByNamesResult& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + void __set_o3(const InvalidObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_partitions_by_names_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_by_names_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_by_names_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_by_names_req_presult__isset { + _ThriftHiveMetastore_get_partitions_by_names_req_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_get_partitions_by_names_req_presult__isset; + +class ThriftHiveMetastore_get_partitions_by_names_req_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_by_names_req_presult() noexcept; + GetPartitionsByNamesResult* success; + MetaException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + + _ThriftHiveMetastore_get_partitions_by_names_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_properties_args__isset { + _ThriftHiveMetastore_get_properties_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_get_properties_args__isset; + +class ThriftHiveMetastore_get_properties_args { + public: + + ThriftHiveMetastore_get_properties_args(const ThriftHiveMetastore_get_properties_args&); + ThriftHiveMetastore_get_properties_args& operator=(const ThriftHiveMetastore_get_properties_args&); + ThriftHiveMetastore_get_properties_args() noexcept; + + virtual ~ThriftHiveMetastore_get_properties_args() noexcept; + PropertyGetRequest req; + + _ThriftHiveMetastore_get_properties_args__isset __isset; + + void __set_req(const PropertyGetRequest& val); + + bool operator == (const ThriftHiveMetastore_get_properties_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_properties_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_properties_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_properties_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_properties_pargs() noexcept; + const PropertyGetRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_properties_result__isset { + _ThriftHiveMetastore_get_properties_result__isset() : success(false), e1(false), e2(false) {} + bool success :1; + bool e1 :1; + bool e2 :1; +} _ThriftHiveMetastore_get_properties_result__isset; + +class ThriftHiveMetastore_get_properties_result { + public: + + ThriftHiveMetastore_get_properties_result(const ThriftHiveMetastore_get_properties_result&); + ThriftHiveMetastore_get_properties_result& operator=(const ThriftHiveMetastore_get_properties_result&); + ThriftHiveMetastore_get_properties_result() noexcept; + + virtual ~ThriftHiveMetastore_get_properties_result() noexcept; + PropertyGetResponse success; + MetaException e1; + NoSuchObjectException e2; + + _ThriftHiveMetastore_get_properties_result__isset __isset; + + void __set_success(const PropertyGetResponse& val); + + void __set_e1(const MetaException& val); + + void __set_e2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_properties_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_properties_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_properties_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_properties_presult__isset { + _ThriftHiveMetastore_get_properties_presult__isset() : success(false), e1(false), e2(false) {} + bool success :1; + bool e1 :1; + bool e2 :1; +} _ThriftHiveMetastore_get_properties_presult__isset; + +class ThriftHiveMetastore_get_properties_presult { + public: + + + virtual ~ThriftHiveMetastore_get_properties_presult() noexcept; + PropertyGetResponse* success; + MetaException e1; + NoSuchObjectException e2; + + _ThriftHiveMetastore_get_properties_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_set_properties_args__isset { + _ThriftHiveMetastore_set_properties_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_set_properties_args__isset; + +class ThriftHiveMetastore_set_properties_args { + public: + + ThriftHiveMetastore_set_properties_args(const ThriftHiveMetastore_set_properties_args&); + ThriftHiveMetastore_set_properties_args& operator=(const ThriftHiveMetastore_set_properties_args&); + ThriftHiveMetastore_set_properties_args() noexcept; + + virtual ~ThriftHiveMetastore_set_properties_args() noexcept; + PropertySetRequest req; + + _ThriftHiveMetastore_set_properties_args__isset __isset; + + void __set_req(const PropertySetRequest& val); + + bool operator == (const ThriftHiveMetastore_set_properties_args & rhs) const; + bool operator != (const ThriftHiveMetastore_set_properties_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_set_properties_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_set_properties_pargs { + public: + + + virtual ~ThriftHiveMetastore_set_properties_pargs() noexcept; + const PropertySetRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_set_properties_result__isset { + _ThriftHiveMetastore_set_properties_result__isset() : success(false), e1(false), e2(false) {} + bool success :1; + bool e1 :1; + bool e2 :1; +} _ThriftHiveMetastore_set_properties_result__isset; + +class ThriftHiveMetastore_set_properties_result { + public: + + ThriftHiveMetastore_set_properties_result(const ThriftHiveMetastore_set_properties_result&); + ThriftHiveMetastore_set_properties_result& operator=(const ThriftHiveMetastore_set_properties_result&); + ThriftHiveMetastore_set_properties_result() noexcept; + + virtual ~ThriftHiveMetastore_set_properties_result() noexcept; + bool success; + MetaException e1; + NoSuchObjectException e2; + + _ThriftHiveMetastore_set_properties_result__isset __isset; + + void __set_success(const bool val); + + void __set_e1(const MetaException& val); + + void __set_e2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_set_properties_result & rhs) const; + bool operator != (const ThriftHiveMetastore_set_properties_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_set_properties_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_set_properties_presult__isset { + _ThriftHiveMetastore_set_properties_presult__isset() : success(false), e1(false), e2(false) {} + bool success :1; + bool e1 :1; + bool e2 :1; +} _ThriftHiveMetastore_set_properties_presult__isset; + +class ThriftHiveMetastore_set_properties_presult { + public: + + + virtual ~ThriftHiveMetastore_set_properties_presult() noexcept; + bool* success; + MetaException e1; + NoSuchObjectException e2; + + _ThriftHiveMetastore_set_properties_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_alter_partition_args__isset { + _ThriftHiveMetastore_alter_partition_args__isset() : db_name(false), tbl_name(false), new_part(false) {} + bool db_name :1; + bool tbl_name :1; + bool new_part :1; +} _ThriftHiveMetastore_alter_partition_args__isset; + +class ThriftHiveMetastore_alter_partition_args { + public: + + ThriftHiveMetastore_alter_partition_args(const ThriftHiveMetastore_alter_partition_args&); + ThriftHiveMetastore_alter_partition_args& operator=(const ThriftHiveMetastore_alter_partition_args&); + ThriftHiveMetastore_alter_partition_args() noexcept; + + virtual ~ThriftHiveMetastore_alter_partition_args() noexcept; + std::string db_name; + std::string tbl_name; + Partition new_part; + + _ThriftHiveMetastore_alter_partition_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_new_part(const Partition& val); + + bool operator == (const ThriftHiveMetastore_alter_partition_args & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_partition_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_partition_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_alter_partition_pargs { + public: + + + virtual ~ThriftHiveMetastore_alter_partition_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const Partition* new_part; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_partition_result__isset { + _ThriftHiveMetastore_alter_partition_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_partition_result__isset; + +class ThriftHiveMetastore_alter_partition_result { + public: + + ThriftHiveMetastore_alter_partition_result(const ThriftHiveMetastore_alter_partition_result&); + ThriftHiveMetastore_alter_partition_result& operator=(const ThriftHiveMetastore_alter_partition_result&); + ThriftHiveMetastore_alter_partition_result() noexcept; + + virtual ~ThriftHiveMetastore_alter_partition_result() noexcept; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_partition_result__isset __isset; + + void __set_o1(const InvalidOperationException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_alter_partition_result & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_partition_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_partition_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_partition_presult__isset { + _ThriftHiveMetastore_alter_partition_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_partition_presult__isset; + +class ThriftHiveMetastore_alter_partition_presult { + public: + + + virtual ~ThriftHiveMetastore_alter_partition_presult() noexcept; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_partition_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_alter_partitions_args__isset { + _ThriftHiveMetastore_alter_partitions_args__isset() : db_name(false), tbl_name(false), new_parts(false) {} + bool db_name :1; + bool tbl_name :1; + bool new_parts :1; +} _ThriftHiveMetastore_alter_partitions_args__isset; + +class ThriftHiveMetastore_alter_partitions_args { + public: + + ThriftHiveMetastore_alter_partitions_args(const ThriftHiveMetastore_alter_partitions_args&); + ThriftHiveMetastore_alter_partitions_args& operator=(const ThriftHiveMetastore_alter_partitions_args&); + ThriftHiveMetastore_alter_partitions_args() noexcept; + + virtual ~ThriftHiveMetastore_alter_partitions_args() noexcept; + std::string db_name; + std::string tbl_name; + std::vector new_parts; + + _ThriftHiveMetastore_alter_partitions_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_new_parts(const std::vector & val); + + bool operator == (const ThriftHiveMetastore_alter_partitions_args & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_partitions_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_partitions_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_alter_partitions_pargs { + public: + + + virtual ~ThriftHiveMetastore_alter_partitions_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::vector * new_parts; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_partitions_result__isset { + _ThriftHiveMetastore_alter_partitions_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_partitions_result__isset; + +class ThriftHiveMetastore_alter_partitions_result { + public: + + ThriftHiveMetastore_alter_partitions_result(const ThriftHiveMetastore_alter_partitions_result&); + ThriftHiveMetastore_alter_partitions_result& operator=(const ThriftHiveMetastore_alter_partitions_result&); + ThriftHiveMetastore_alter_partitions_result() noexcept; + + virtual ~ThriftHiveMetastore_alter_partitions_result() noexcept; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_partitions_result__isset __isset; + + void __set_o1(const InvalidOperationException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_alter_partitions_result & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_partitions_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_partitions_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_partitions_presult__isset { + _ThriftHiveMetastore_alter_partitions_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_partitions_presult__isset; + +class ThriftHiveMetastore_alter_partitions_presult { + public: + + + virtual ~ThriftHiveMetastore_alter_partitions_presult() noexcept; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_partitions_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_alter_partitions_with_environment_context_args__isset { + _ThriftHiveMetastore_alter_partitions_with_environment_context_args__isset() : db_name(false), tbl_name(false), new_parts(false), environment_context(false) {} + bool db_name :1; + bool tbl_name :1; + bool new_parts :1; + bool environment_context :1; +} _ThriftHiveMetastore_alter_partitions_with_environment_context_args__isset; + +class ThriftHiveMetastore_alter_partitions_with_environment_context_args { + public: + + ThriftHiveMetastore_alter_partitions_with_environment_context_args(const ThriftHiveMetastore_alter_partitions_with_environment_context_args&); + ThriftHiveMetastore_alter_partitions_with_environment_context_args& operator=(const ThriftHiveMetastore_alter_partitions_with_environment_context_args&); + ThriftHiveMetastore_alter_partitions_with_environment_context_args() noexcept; + + virtual ~ThriftHiveMetastore_alter_partitions_with_environment_context_args() noexcept; + std::string db_name; + std::string tbl_name; + std::vector new_parts; + EnvironmentContext environment_context; + + _ThriftHiveMetastore_alter_partitions_with_environment_context_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_new_parts(const std::vector & val); + + void __set_environment_context(const EnvironmentContext& val); + + bool operator == (const ThriftHiveMetastore_alter_partitions_with_environment_context_args & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_partitions_with_environment_context_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_partitions_with_environment_context_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_alter_partitions_with_environment_context_pargs { + public: + + + virtual ~ThriftHiveMetastore_alter_partitions_with_environment_context_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::vector * new_parts; + const EnvironmentContext* environment_context; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_partitions_with_environment_context_result__isset { + _ThriftHiveMetastore_alter_partitions_with_environment_context_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_partitions_with_environment_context_result__isset; + +class ThriftHiveMetastore_alter_partitions_with_environment_context_result { + public: + + ThriftHiveMetastore_alter_partitions_with_environment_context_result(const ThriftHiveMetastore_alter_partitions_with_environment_context_result&); + ThriftHiveMetastore_alter_partitions_with_environment_context_result& operator=(const ThriftHiveMetastore_alter_partitions_with_environment_context_result&); + ThriftHiveMetastore_alter_partitions_with_environment_context_result() noexcept; + + virtual ~ThriftHiveMetastore_alter_partitions_with_environment_context_result() noexcept; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_partitions_with_environment_context_result__isset __isset; + + void __set_o1(const InvalidOperationException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_alter_partitions_with_environment_context_result & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_partitions_with_environment_context_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_partitions_with_environment_context_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_partitions_with_environment_context_presult__isset { + _ThriftHiveMetastore_alter_partitions_with_environment_context_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_partitions_with_environment_context_presult__isset; + +class ThriftHiveMetastore_alter_partitions_with_environment_context_presult { + public: + + + virtual ~ThriftHiveMetastore_alter_partitions_with_environment_context_presult() noexcept; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_partitions_with_environment_context_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_alter_partitions_req_args__isset { + _ThriftHiveMetastore_alter_partitions_req_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_alter_partitions_req_args__isset; + +class ThriftHiveMetastore_alter_partitions_req_args { + public: + + ThriftHiveMetastore_alter_partitions_req_args(const ThriftHiveMetastore_alter_partitions_req_args&); + ThriftHiveMetastore_alter_partitions_req_args& operator=(const ThriftHiveMetastore_alter_partitions_req_args&); + ThriftHiveMetastore_alter_partitions_req_args() noexcept; + + virtual ~ThriftHiveMetastore_alter_partitions_req_args() noexcept; + AlterPartitionsRequest req; + + _ThriftHiveMetastore_alter_partitions_req_args__isset __isset; + + void __set_req(const AlterPartitionsRequest& val); + + bool operator == (const ThriftHiveMetastore_alter_partitions_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_partitions_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_partitions_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_alter_partitions_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_alter_partitions_req_pargs() noexcept; + const AlterPartitionsRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_partitions_req_result__isset { + _ThriftHiveMetastore_alter_partitions_req_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_partitions_req_result__isset; + +class ThriftHiveMetastore_alter_partitions_req_result { + public: + + ThriftHiveMetastore_alter_partitions_req_result(const ThriftHiveMetastore_alter_partitions_req_result&); + ThriftHiveMetastore_alter_partitions_req_result& operator=(const ThriftHiveMetastore_alter_partitions_req_result&); + ThriftHiveMetastore_alter_partitions_req_result() noexcept; + + virtual ~ThriftHiveMetastore_alter_partitions_req_result() noexcept; + AlterPartitionsResponse success; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_partitions_req_result__isset __isset; + + void __set_success(const AlterPartitionsResponse& val); + + void __set_o1(const InvalidOperationException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_alter_partitions_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_partitions_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_partitions_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_partitions_req_presult__isset { + _ThriftHiveMetastore_alter_partitions_req_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_partitions_req_presult__isset; + +class ThriftHiveMetastore_alter_partitions_req_presult { + public: + + + virtual ~ThriftHiveMetastore_alter_partitions_req_presult() noexcept; + AlterPartitionsResponse* success; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_partitions_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_alter_partition_with_environment_context_args__isset { + _ThriftHiveMetastore_alter_partition_with_environment_context_args__isset() : db_name(false), tbl_name(false), new_part(false), environment_context(false) {} + bool db_name :1; + bool tbl_name :1; + bool new_part :1; + bool environment_context :1; +} _ThriftHiveMetastore_alter_partition_with_environment_context_args__isset; + +class ThriftHiveMetastore_alter_partition_with_environment_context_args { + public: + + ThriftHiveMetastore_alter_partition_with_environment_context_args(const ThriftHiveMetastore_alter_partition_with_environment_context_args&); + ThriftHiveMetastore_alter_partition_with_environment_context_args& operator=(const ThriftHiveMetastore_alter_partition_with_environment_context_args&); + ThriftHiveMetastore_alter_partition_with_environment_context_args() noexcept; + + virtual ~ThriftHiveMetastore_alter_partition_with_environment_context_args() noexcept; + std::string db_name; + std::string tbl_name; + Partition new_part; + EnvironmentContext environment_context; + + _ThriftHiveMetastore_alter_partition_with_environment_context_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_new_part(const Partition& val); + + void __set_environment_context(const EnvironmentContext& val); + + bool operator == (const ThriftHiveMetastore_alter_partition_with_environment_context_args & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_partition_with_environment_context_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_partition_with_environment_context_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_alter_partition_with_environment_context_pargs { + public: + + + virtual ~ThriftHiveMetastore_alter_partition_with_environment_context_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const Partition* new_part; + const EnvironmentContext* environment_context; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_partition_with_environment_context_result__isset { + _ThriftHiveMetastore_alter_partition_with_environment_context_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_partition_with_environment_context_result__isset; + +class ThriftHiveMetastore_alter_partition_with_environment_context_result { + public: + + ThriftHiveMetastore_alter_partition_with_environment_context_result(const ThriftHiveMetastore_alter_partition_with_environment_context_result&); + ThriftHiveMetastore_alter_partition_with_environment_context_result& operator=(const ThriftHiveMetastore_alter_partition_with_environment_context_result&); + ThriftHiveMetastore_alter_partition_with_environment_context_result() noexcept; + + virtual ~ThriftHiveMetastore_alter_partition_with_environment_context_result() noexcept; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_partition_with_environment_context_result__isset __isset; + + void __set_o1(const InvalidOperationException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_alter_partition_with_environment_context_result & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_partition_with_environment_context_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_partition_with_environment_context_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_partition_with_environment_context_presult__isset { + _ThriftHiveMetastore_alter_partition_with_environment_context_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_partition_with_environment_context_presult__isset; + +class ThriftHiveMetastore_alter_partition_with_environment_context_presult { + public: + + + virtual ~ThriftHiveMetastore_alter_partition_with_environment_context_presult() noexcept; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_partition_with_environment_context_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_rename_partition_args__isset { + _ThriftHiveMetastore_rename_partition_args__isset() : db_name(false), tbl_name(false), part_vals(false), new_part(false) {} + bool db_name :1; + bool tbl_name :1; + bool part_vals :1; + bool new_part :1; +} _ThriftHiveMetastore_rename_partition_args__isset; + +class ThriftHiveMetastore_rename_partition_args { + public: + + ThriftHiveMetastore_rename_partition_args(const ThriftHiveMetastore_rename_partition_args&); + ThriftHiveMetastore_rename_partition_args& operator=(const ThriftHiveMetastore_rename_partition_args&); + ThriftHiveMetastore_rename_partition_args() noexcept; + + virtual ~ThriftHiveMetastore_rename_partition_args() noexcept; + std::string db_name; + std::string tbl_name; + std::vector part_vals; + Partition new_part; + + _ThriftHiveMetastore_rename_partition_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_part_vals(const std::vector & val); + + void __set_new_part(const Partition& val); + + bool operator == (const ThriftHiveMetastore_rename_partition_args & rhs) const; + bool operator != (const ThriftHiveMetastore_rename_partition_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_rename_partition_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_rename_partition_pargs { + public: + + + virtual ~ThriftHiveMetastore_rename_partition_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::vector * part_vals; + const Partition* new_part; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_rename_partition_result__isset { + _ThriftHiveMetastore_rename_partition_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_rename_partition_result__isset; + +class ThriftHiveMetastore_rename_partition_result { + public: + + ThriftHiveMetastore_rename_partition_result(const ThriftHiveMetastore_rename_partition_result&); + ThriftHiveMetastore_rename_partition_result& operator=(const ThriftHiveMetastore_rename_partition_result&); + ThriftHiveMetastore_rename_partition_result() noexcept; + + virtual ~ThriftHiveMetastore_rename_partition_result() noexcept; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_rename_partition_result__isset __isset; + + void __set_o1(const InvalidOperationException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_rename_partition_result & rhs) const; + bool operator != (const ThriftHiveMetastore_rename_partition_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_rename_partition_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_rename_partition_presult__isset { + _ThriftHiveMetastore_rename_partition_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_rename_partition_presult__isset; + +class ThriftHiveMetastore_rename_partition_presult { + public: + + + virtual ~ThriftHiveMetastore_rename_partition_presult() noexcept; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_rename_partition_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_rename_partition_req_args__isset { + _ThriftHiveMetastore_rename_partition_req_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_rename_partition_req_args__isset; + +class ThriftHiveMetastore_rename_partition_req_args { + public: + + ThriftHiveMetastore_rename_partition_req_args(const ThriftHiveMetastore_rename_partition_req_args&); + ThriftHiveMetastore_rename_partition_req_args& operator=(const ThriftHiveMetastore_rename_partition_req_args&); + ThriftHiveMetastore_rename_partition_req_args() noexcept; + + virtual ~ThriftHiveMetastore_rename_partition_req_args() noexcept; + RenamePartitionRequest req; + + _ThriftHiveMetastore_rename_partition_req_args__isset __isset; + + void __set_req(const RenamePartitionRequest& val); + + bool operator == (const ThriftHiveMetastore_rename_partition_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_rename_partition_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_rename_partition_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_rename_partition_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_rename_partition_req_pargs() noexcept; + const RenamePartitionRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_rename_partition_req_result__isset { + _ThriftHiveMetastore_rename_partition_req_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_rename_partition_req_result__isset; + +class ThriftHiveMetastore_rename_partition_req_result { + public: + + ThriftHiveMetastore_rename_partition_req_result(const ThriftHiveMetastore_rename_partition_req_result&); + ThriftHiveMetastore_rename_partition_req_result& operator=(const ThriftHiveMetastore_rename_partition_req_result&); + ThriftHiveMetastore_rename_partition_req_result() noexcept; + + virtual ~ThriftHiveMetastore_rename_partition_req_result() noexcept; + RenamePartitionResponse success; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_rename_partition_req_result__isset __isset; + + void __set_success(const RenamePartitionResponse& val); + + void __set_o1(const InvalidOperationException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_rename_partition_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_rename_partition_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_rename_partition_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_rename_partition_req_presult__isset { + _ThriftHiveMetastore_rename_partition_req_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_rename_partition_req_presult__isset; + +class ThriftHiveMetastore_rename_partition_req_presult { + public: + + + virtual ~ThriftHiveMetastore_rename_partition_req_presult() noexcept; + RenamePartitionResponse* success; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_rename_partition_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_partition_name_has_valid_characters_args__isset { + _ThriftHiveMetastore_partition_name_has_valid_characters_args__isset() : part_vals(false), throw_exception(false) {} + bool part_vals :1; + bool throw_exception :1; +} _ThriftHiveMetastore_partition_name_has_valid_characters_args__isset; + +class ThriftHiveMetastore_partition_name_has_valid_characters_args { + public: + + ThriftHiveMetastore_partition_name_has_valid_characters_args(const ThriftHiveMetastore_partition_name_has_valid_characters_args&); + ThriftHiveMetastore_partition_name_has_valid_characters_args& operator=(const ThriftHiveMetastore_partition_name_has_valid_characters_args&); + ThriftHiveMetastore_partition_name_has_valid_characters_args() noexcept; + + virtual ~ThriftHiveMetastore_partition_name_has_valid_characters_args() noexcept; + std::vector part_vals; + bool throw_exception; + + _ThriftHiveMetastore_partition_name_has_valid_characters_args__isset __isset; + + void __set_part_vals(const std::vector & val); + + void __set_throw_exception(const bool val); + + bool operator == (const ThriftHiveMetastore_partition_name_has_valid_characters_args & rhs) const; + bool operator != (const ThriftHiveMetastore_partition_name_has_valid_characters_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_partition_name_has_valid_characters_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_partition_name_has_valid_characters_pargs { + public: + + + virtual ~ThriftHiveMetastore_partition_name_has_valid_characters_pargs() noexcept; + const std::vector * part_vals; + const bool* throw_exception; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_partition_name_has_valid_characters_result__isset { + _ThriftHiveMetastore_partition_name_has_valid_characters_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_partition_name_has_valid_characters_result__isset; + +class ThriftHiveMetastore_partition_name_has_valid_characters_result { + public: + + ThriftHiveMetastore_partition_name_has_valid_characters_result(const ThriftHiveMetastore_partition_name_has_valid_characters_result&); + ThriftHiveMetastore_partition_name_has_valid_characters_result& operator=(const ThriftHiveMetastore_partition_name_has_valid_characters_result&); + ThriftHiveMetastore_partition_name_has_valid_characters_result() noexcept; + + virtual ~ThriftHiveMetastore_partition_name_has_valid_characters_result() noexcept; + bool success; + MetaException o1; + + _ThriftHiveMetastore_partition_name_has_valid_characters_result__isset __isset; + + void __set_success(const bool val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_partition_name_has_valid_characters_result & rhs) const; + bool operator != (const ThriftHiveMetastore_partition_name_has_valid_characters_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_partition_name_has_valid_characters_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_partition_name_has_valid_characters_presult__isset { + _ThriftHiveMetastore_partition_name_has_valid_characters_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_partition_name_has_valid_characters_presult__isset; + +class ThriftHiveMetastore_partition_name_has_valid_characters_presult { + public: + + + virtual ~ThriftHiveMetastore_partition_name_has_valid_characters_presult() noexcept; + bool* success; + MetaException o1; + + _ThriftHiveMetastore_partition_name_has_valid_characters_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_config_value_args__isset { + _ThriftHiveMetastore_get_config_value_args__isset() : name(false), defaultValue(false) {} + bool name :1; + bool defaultValue :1; +} _ThriftHiveMetastore_get_config_value_args__isset; + +class ThriftHiveMetastore_get_config_value_args { + public: + + ThriftHiveMetastore_get_config_value_args(const ThriftHiveMetastore_get_config_value_args&); + ThriftHiveMetastore_get_config_value_args& operator=(const ThriftHiveMetastore_get_config_value_args&); + ThriftHiveMetastore_get_config_value_args() noexcept; + + virtual ~ThriftHiveMetastore_get_config_value_args() noexcept; + std::string name; + std::string defaultValue; + + _ThriftHiveMetastore_get_config_value_args__isset __isset; + + void __set_name(const std::string& val); + + void __set_defaultValue(const std::string& val); + + bool operator == (const ThriftHiveMetastore_get_config_value_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_config_value_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_config_value_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_config_value_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_config_value_pargs() noexcept; + const std::string* name; + const std::string* defaultValue; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_config_value_result__isset { + _ThriftHiveMetastore_get_config_value_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_config_value_result__isset; + +class ThriftHiveMetastore_get_config_value_result { + public: + + ThriftHiveMetastore_get_config_value_result(const ThriftHiveMetastore_get_config_value_result&); + ThriftHiveMetastore_get_config_value_result& operator=(const ThriftHiveMetastore_get_config_value_result&); + ThriftHiveMetastore_get_config_value_result() noexcept; + + virtual ~ThriftHiveMetastore_get_config_value_result() noexcept; + std::string success; + ConfigValSecurityException o1; + + _ThriftHiveMetastore_get_config_value_result__isset __isset; + + void __set_success(const std::string& val); + + void __set_o1(const ConfigValSecurityException& val); + + bool operator == (const ThriftHiveMetastore_get_config_value_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_config_value_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_config_value_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_config_value_presult__isset { + _ThriftHiveMetastore_get_config_value_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_config_value_presult__isset; + +class ThriftHiveMetastore_get_config_value_presult { + public: + + + virtual ~ThriftHiveMetastore_get_config_value_presult() noexcept; + std::string* success; + ConfigValSecurityException o1; + + _ThriftHiveMetastore_get_config_value_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_partition_name_to_vals_args__isset { + _ThriftHiveMetastore_partition_name_to_vals_args__isset() : part_name(false) {} + bool part_name :1; +} _ThriftHiveMetastore_partition_name_to_vals_args__isset; + +class ThriftHiveMetastore_partition_name_to_vals_args { + public: + + ThriftHiveMetastore_partition_name_to_vals_args(const ThriftHiveMetastore_partition_name_to_vals_args&); + ThriftHiveMetastore_partition_name_to_vals_args& operator=(const ThriftHiveMetastore_partition_name_to_vals_args&); + ThriftHiveMetastore_partition_name_to_vals_args() noexcept; + + virtual ~ThriftHiveMetastore_partition_name_to_vals_args() noexcept; + std::string part_name; + + _ThriftHiveMetastore_partition_name_to_vals_args__isset __isset; + + void __set_part_name(const std::string& val); + + bool operator == (const ThriftHiveMetastore_partition_name_to_vals_args & rhs) const; + bool operator != (const ThriftHiveMetastore_partition_name_to_vals_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_partition_name_to_vals_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_partition_name_to_vals_pargs { + public: + + + virtual ~ThriftHiveMetastore_partition_name_to_vals_pargs() noexcept; + const std::string* part_name; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_partition_name_to_vals_result__isset { + _ThriftHiveMetastore_partition_name_to_vals_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_partition_name_to_vals_result__isset; + +class ThriftHiveMetastore_partition_name_to_vals_result { + public: + + ThriftHiveMetastore_partition_name_to_vals_result(const ThriftHiveMetastore_partition_name_to_vals_result&); + ThriftHiveMetastore_partition_name_to_vals_result& operator=(const ThriftHiveMetastore_partition_name_to_vals_result&); + ThriftHiveMetastore_partition_name_to_vals_result() noexcept; + + virtual ~ThriftHiveMetastore_partition_name_to_vals_result() noexcept; + std::vector success; + MetaException o1; + + _ThriftHiveMetastore_partition_name_to_vals_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_partition_name_to_vals_result & rhs) const; + bool operator != (const ThriftHiveMetastore_partition_name_to_vals_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_partition_name_to_vals_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_partition_name_to_vals_presult__isset { + _ThriftHiveMetastore_partition_name_to_vals_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_partition_name_to_vals_presult__isset; + +class ThriftHiveMetastore_partition_name_to_vals_presult { + public: + + + virtual ~ThriftHiveMetastore_partition_name_to_vals_presult() noexcept; + std::vector * success; + MetaException o1; + + _ThriftHiveMetastore_partition_name_to_vals_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_partition_name_to_spec_args__isset { + _ThriftHiveMetastore_partition_name_to_spec_args__isset() : part_name(false) {} + bool part_name :1; +} _ThriftHiveMetastore_partition_name_to_spec_args__isset; + +class ThriftHiveMetastore_partition_name_to_spec_args { + public: + + ThriftHiveMetastore_partition_name_to_spec_args(const ThriftHiveMetastore_partition_name_to_spec_args&); + ThriftHiveMetastore_partition_name_to_spec_args& operator=(const ThriftHiveMetastore_partition_name_to_spec_args&); + ThriftHiveMetastore_partition_name_to_spec_args() noexcept; + + virtual ~ThriftHiveMetastore_partition_name_to_spec_args() noexcept; + std::string part_name; + + _ThriftHiveMetastore_partition_name_to_spec_args__isset __isset; + + void __set_part_name(const std::string& val); + + bool operator == (const ThriftHiveMetastore_partition_name_to_spec_args & rhs) const; + bool operator != (const ThriftHiveMetastore_partition_name_to_spec_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_partition_name_to_spec_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_partition_name_to_spec_pargs { + public: + + + virtual ~ThriftHiveMetastore_partition_name_to_spec_pargs() noexcept; + const std::string* part_name; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_partition_name_to_spec_result__isset { + _ThriftHiveMetastore_partition_name_to_spec_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_partition_name_to_spec_result__isset; + +class ThriftHiveMetastore_partition_name_to_spec_result { + public: + + ThriftHiveMetastore_partition_name_to_spec_result(const ThriftHiveMetastore_partition_name_to_spec_result&); + ThriftHiveMetastore_partition_name_to_spec_result& operator=(const ThriftHiveMetastore_partition_name_to_spec_result&); + ThriftHiveMetastore_partition_name_to_spec_result() noexcept; + + virtual ~ThriftHiveMetastore_partition_name_to_spec_result() noexcept; + std::map success; + MetaException o1; + + _ThriftHiveMetastore_partition_name_to_spec_result__isset __isset; + + void __set_success(const std::map & val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_partition_name_to_spec_result & rhs) const; + bool operator != (const ThriftHiveMetastore_partition_name_to_spec_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_partition_name_to_spec_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_partition_name_to_spec_presult__isset { + _ThriftHiveMetastore_partition_name_to_spec_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_partition_name_to_spec_presult__isset; + +class ThriftHiveMetastore_partition_name_to_spec_presult { + public: + + + virtual ~ThriftHiveMetastore_partition_name_to_spec_presult() noexcept; + std::map * success; + MetaException o1; + + _ThriftHiveMetastore_partition_name_to_spec_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_markPartitionForEvent_args__isset { + _ThriftHiveMetastore_markPartitionForEvent_args__isset() : db_name(false), tbl_name(false), part_vals(false), eventType(false) {} + bool db_name :1; + bool tbl_name :1; + bool part_vals :1; + bool eventType :1; +} _ThriftHiveMetastore_markPartitionForEvent_args__isset; + +class ThriftHiveMetastore_markPartitionForEvent_args { + public: + + ThriftHiveMetastore_markPartitionForEvent_args(const ThriftHiveMetastore_markPartitionForEvent_args&); + ThriftHiveMetastore_markPartitionForEvent_args& operator=(const ThriftHiveMetastore_markPartitionForEvent_args&); + ThriftHiveMetastore_markPartitionForEvent_args() noexcept; + + virtual ~ThriftHiveMetastore_markPartitionForEvent_args() noexcept; + std::string db_name; + std::string tbl_name; + std::map part_vals; + /** + * + * @see PartitionEventType + */ + PartitionEventType::type eventType; + + _ThriftHiveMetastore_markPartitionForEvent_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_part_vals(const std::map & val); + + void __set_eventType(const PartitionEventType::type val); + + bool operator == (const ThriftHiveMetastore_markPartitionForEvent_args & rhs) const; + bool operator != (const ThriftHiveMetastore_markPartitionForEvent_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_markPartitionForEvent_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_markPartitionForEvent_pargs { + public: + + + virtual ~ThriftHiveMetastore_markPartitionForEvent_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::map * part_vals; + /** + * + * @see PartitionEventType + */ + const PartitionEventType::type* eventType; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_markPartitionForEvent_result__isset { + _ThriftHiveMetastore_markPartitionForEvent_result__isset() : o1(false), o2(false), o3(false), o4(false), o5(false), o6(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; + bool o5 :1; + bool o6 :1; +} _ThriftHiveMetastore_markPartitionForEvent_result__isset; + +class ThriftHiveMetastore_markPartitionForEvent_result { + public: + + ThriftHiveMetastore_markPartitionForEvent_result(const ThriftHiveMetastore_markPartitionForEvent_result&); + ThriftHiveMetastore_markPartitionForEvent_result& operator=(const ThriftHiveMetastore_markPartitionForEvent_result&); + ThriftHiveMetastore_markPartitionForEvent_result() noexcept; + + virtual ~ThriftHiveMetastore_markPartitionForEvent_result() noexcept; + MetaException o1; + NoSuchObjectException o2; + UnknownDBException o3; + UnknownTableException o4; + UnknownPartitionException o5; + InvalidPartitionException o6; + + _ThriftHiveMetastore_markPartitionForEvent_result__isset __isset; + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + void __set_o3(const UnknownDBException& val); + + void __set_o4(const UnknownTableException& val); + + void __set_o5(const UnknownPartitionException& val); + + void __set_o6(const InvalidPartitionException& val); + + bool operator == (const ThriftHiveMetastore_markPartitionForEvent_result & rhs) const; + bool operator != (const ThriftHiveMetastore_markPartitionForEvent_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_markPartitionForEvent_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_markPartitionForEvent_presult__isset { + _ThriftHiveMetastore_markPartitionForEvent_presult__isset() : o1(false), o2(false), o3(false), o4(false), o5(false), o6(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; + bool o5 :1; + bool o6 :1; +} _ThriftHiveMetastore_markPartitionForEvent_presult__isset; + +class ThriftHiveMetastore_markPartitionForEvent_presult { + public: + + + virtual ~ThriftHiveMetastore_markPartitionForEvent_presult() noexcept; + MetaException o1; + NoSuchObjectException o2; + UnknownDBException o3; + UnknownTableException o4; + UnknownPartitionException o5; + InvalidPartitionException o6; + + _ThriftHiveMetastore_markPartitionForEvent_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_isPartitionMarkedForEvent_args__isset { + _ThriftHiveMetastore_isPartitionMarkedForEvent_args__isset() : db_name(false), tbl_name(false), part_vals(false), eventType(false) {} + bool db_name :1; + bool tbl_name :1; + bool part_vals :1; + bool eventType :1; +} _ThriftHiveMetastore_isPartitionMarkedForEvent_args__isset; + +class ThriftHiveMetastore_isPartitionMarkedForEvent_args { + public: + + ThriftHiveMetastore_isPartitionMarkedForEvent_args(const ThriftHiveMetastore_isPartitionMarkedForEvent_args&); + ThriftHiveMetastore_isPartitionMarkedForEvent_args& operator=(const ThriftHiveMetastore_isPartitionMarkedForEvent_args&); + ThriftHiveMetastore_isPartitionMarkedForEvent_args() noexcept; + + virtual ~ThriftHiveMetastore_isPartitionMarkedForEvent_args() noexcept; + std::string db_name; + std::string tbl_name; + std::map part_vals; + /** + * + * @see PartitionEventType + */ + PartitionEventType::type eventType; + + _ThriftHiveMetastore_isPartitionMarkedForEvent_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_part_vals(const std::map & val); + + void __set_eventType(const PartitionEventType::type val); + + bool operator == (const ThriftHiveMetastore_isPartitionMarkedForEvent_args & rhs) const; + bool operator != (const ThriftHiveMetastore_isPartitionMarkedForEvent_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_isPartitionMarkedForEvent_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_isPartitionMarkedForEvent_pargs { + public: + + + virtual ~ThriftHiveMetastore_isPartitionMarkedForEvent_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::map * part_vals; + /** + * + * @see PartitionEventType + */ + const PartitionEventType::type* eventType; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_isPartitionMarkedForEvent_result__isset { + _ThriftHiveMetastore_isPartitionMarkedForEvent_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false), o5(false), o6(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; + bool o5 :1; + bool o6 :1; +} _ThriftHiveMetastore_isPartitionMarkedForEvent_result__isset; + +class ThriftHiveMetastore_isPartitionMarkedForEvent_result { + public: + + ThriftHiveMetastore_isPartitionMarkedForEvent_result(const ThriftHiveMetastore_isPartitionMarkedForEvent_result&); + ThriftHiveMetastore_isPartitionMarkedForEvent_result& operator=(const ThriftHiveMetastore_isPartitionMarkedForEvent_result&); + ThriftHiveMetastore_isPartitionMarkedForEvent_result() noexcept; + + virtual ~ThriftHiveMetastore_isPartitionMarkedForEvent_result() noexcept; + bool success; + MetaException o1; + NoSuchObjectException o2; + UnknownDBException o3; + UnknownTableException o4; + UnknownPartitionException o5; + InvalidPartitionException o6; + + _ThriftHiveMetastore_isPartitionMarkedForEvent_result__isset __isset; + + void __set_success(const bool val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + void __set_o3(const UnknownDBException& val); + + void __set_o4(const UnknownTableException& val); + + void __set_o5(const UnknownPartitionException& val); + + void __set_o6(const InvalidPartitionException& val); + + bool operator == (const ThriftHiveMetastore_isPartitionMarkedForEvent_result & rhs) const; + bool operator != (const ThriftHiveMetastore_isPartitionMarkedForEvent_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_isPartitionMarkedForEvent_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_isPartitionMarkedForEvent_presult__isset { + _ThriftHiveMetastore_isPartitionMarkedForEvent_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false), o5(false), o6(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; + bool o5 :1; + bool o6 :1; +} _ThriftHiveMetastore_isPartitionMarkedForEvent_presult__isset; + +class ThriftHiveMetastore_isPartitionMarkedForEvent_presult { + public: + + + virtual ~ThriftHiveMetastore_isPartitionMarkedForEvent_presult() noexcept; + bool* success; + MetaException o1; + NoSuchObjectException o2; + UnknownDBException o3; + UnknownTableException o4; + UnknownPartitionException o5; + InvalidPartitionException o6; + + _ThriftHiveMetastore_isPartitionMarkedForEvent_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_primary_keys_args__isset { + _ThriftHiveMetastore_get_primary_keys_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_primary_keys_args__isset; + +class ThriftHiveMetastore_get_primary_keys_args { + public: + + ThriftHiveMetastore_get_primary_keys_args(const ThriftHiveMetastore_get_primary_keys_args&); + ThriftHiveMetastore_get_primary_keys_args& operator=(const ThriftHiveMetastore_get_primary_keys_args&); + ThriftHiveMetastore_get_primary_keys_args() noexcept; + + virtual ~ThriftHiveMetastore_get_primary_keys_args() noexcept; + PrimaryKeysRequest request; + + _ThriftHiveMetastore_get_primary_keys_args__isset __isset; + + void __set_request(const PrimaryKeysRequest& val); + + bool operator == (const ThriftHiveMetastore_get_primary_keys_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_primary_keys_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_primary_keys_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_primary_keys_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_primary_keys_pargs() noexcept; + const PrimaryKeysRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_primary_keys_result__isset { + _ThriftHiveMetastore_get_primary_keys_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_primary_keys_result__isset; + +class ThriftHiveMetastore_get_primary_keys_result { + public: + + ThriftHiveMetastore_get_primary_keys_result(const ThriftHiveMetastore_get_primary_keys_result&); + ThriftHiveMetastore_get_primary_keys_result& operator=(const ThriftHiveMetastore_get_primary_keys_result&); + ThriftHiveMetastore_get_primary_keys_result() noexcept; + + virtual ~ThriftHiveMetastore_get_primary_keys_result() noexcept; + PrimaryKeysResponse success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_primary_keys_result__isset __isset; + + void __set_success(const PrimaryKeysResponse& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_primary_keys_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_primary_keys_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_primary_keys_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_primary_keys_presult__isset { + _ThriftHiveMetastore_get_primary_keys_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_primary_keys_presult__isset; + +class ThriftHiveMetastore_get_primary_keys_presult { + public: + + + virtual ~ThriftHiveMetastore_get_primary_keys_presult() noexcept; + PrimaryKeysResponse* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_primary_keys_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_foreign_keys_args__isset { + _ThriftHiveMetastore_get_foreign_keys_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_foreign_keys_args__isset; + +class ThriftHiveMetastore_get_foreign_keys_args { + public: + + ThriftHiveMetastore_get_foreign_keys_args(const ThriftHiveMetastore_get_foreign_keys_args&); + ThriftHiveMetastore_get_foreign_keys_args& operator=(const ThriftHiveMetastore_get_foreign_keys_args&); + ThriftHiveMetastore_get_foreign_keys_args() noexcept; + + virtual ~ThriftHiveMetastore_get_foreign_keys_args() noexcept; + ForeignKeysRequest request; + + _ThriftHiveMetastore_get_foreign_keys_args__isset __isset; + + void __set_request(const ForeignKeysRequest& val); + + bool operator == (const ThriftHiveMetastore_get_foreign_keys_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_foreign_keys_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_foreign_keys_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_foreign_keys_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_foreign_keys_pargs() noexcept; + const ForeignKeysRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_foreign_keys_result__isset { + _ThriftHiveMetastore_get_foreign_keys_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_foreign_keys_result__isset; + +class ThriftHiveMetastore_get_foreign_keys_result { + public: + + ThriftHiveMetastore_get_foreign_keys_result(const ThriftHiveMetastore_get_foreign_keys_result&); + ThriftHiveMetastore_get_foreign_keys_result& operator=(const ThriftHiveMetastore_get_foreign_keys_result&); + ThriftHiveMetastore_get_foreign_keys_result() noexcept; + + virtual ~ThriftHiveMetastore_get_foreign_keys_result() noexcept; + ForeignKeysResponse success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_foreign_keys_result__isset __isset; + + void __set_success(const ForeignKeysResponse& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_foreign_keys_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_foreign_keys_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_foreign_keys_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_foreign_keys_presult__isset { + _ThriftHiveMetastore_get_foreign_keys_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_foreign_keys_presult__isset; + +class ThriftHiveMetastore_get_foreign_keys_presult { + public: + + + virtual ~ThriftHiveMetastore_get_foreign_keys_presult() noexcept; + ForeignKeysResponse* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_foreign_keys_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_unique_constraints_args__isset { + _ThriftHiveMetastore_get_unique_constraints_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_unique_constraints_args__isset; + +class ThriftHiveMetastore_get_unique_constraints_args { + public: + + ThriftHiveMetastore_get_unique_constraints_args(const ThriftHiveMetastore_get_unique_constraints_args&); + ThriftHiveMetastore_get_unique_constraints_args& operator=(const ThriftHiveMetastore_get_unique_constraints_args&); + ThriftHiveMetastore_get_unique_constraints_args() noexcept; + + virtual ~ThriftHiveMetastore_get_unique_constraints_args() noexcept; + UniqueConstraintsRequest request; + + _ThriftHiveMetastore_get_unique_constraints_args__isset __isset; + + void __set_request(const UniqueConstraintsRequest& val); + + bool operator == (const ThriftHiveMetastore_get_unique_constraints_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_unique_constraints_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_unique_constraints_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_unique_constraints_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_unique_constraints_pargs() noexcept; + const UniqueConstraintsRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_unique_constraints_result__isset { + _ThriftHiveMetastore_get_unique_constraints_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_unique_constraints_result__isset; + +class ThriftHiveMetastore_get_unique_constraints_result { + public: + + ThriftHiveMetastore_get_unique_constraints_result(const ThriftHiveMetastore_get_unique_constraints_result&); + ThriftHiveMetastore_get_unique_constraints_result& operator=(const ThriftHiveMetastore_get_unique_constraints_result&); + ThriftHiveMetastore_get_unique_constraints_result() noexcept; + + virtual ~ThriftHiveMetastore_get_unique_constraints_result() noexcept; + UniqueConstraintsResponse success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_unique_constraints_result__isset __isset; + + void __set_success(const UniqueConstraintsResponse& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_unique_constraints_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_unique_constraints_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_unique_constraints_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_unique_constraints_presult__isset { + _ThriftHiveMetastore_get_unique_constraints_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_unique_constraints_presult__isset; + +class ThriftHiveMetastore_get_unique_constraints_presult { + public: + + + virtual ~ThriftHiveMetastore_get_unique_constraints_presult() noexcept; + UniqueConstraintsResponse* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_unique_constraints_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_not_null_constraints_args__isset { + _ThriftHiveMetastore_get_not_null_constraints_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_not_null_constraints_args__isset; + +class ThriftHiveMetastore_get_not_null_constraints_args { + public: + + ThriftHiveMetastore_get_not_null_constraints_args(const ThriftHiveMetastore_get_not_null_constraints_args&); + ThriftHiveMetastore_get_not_null_constraints_args& operator=(const ThriftHiveMetastore_get_not_null_constraints_args&); + ThriftHiveMetastore_get_not_null_constraints_args() noexcept; + + virtual ~ThriftHiveMetastore_get_not_null_constraints_args() noexcept; + NotNullConstraintsRequest request; + + _ThriftHiveMetastore_get_not_null_constraints_args__isset __isset; + + void __set_request(const NotNullConstraintsRequest& val); + + bool operator == (const ThriftHiveMetastore_get_not_null_constraints_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_not_null_constraints_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_not_null_constraints_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_not_null_constraints_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_not_null_constraints_pargs() noexcept; + const NotNullConstraintsRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_not_null_constraints_result__isset { + _ThriftHiveMetastore_get_not_null_constraints_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_not_null_constraints_result__isset; + +class ThriftHiveMetastore_get_not_null_constraints_result { + public: + + ThriftHiveMetastore_get_not_null_constraints_result(const ThriftHiveMetastore_get_not_null_constraints_result&); + ThriftHiveMetastore_get_not_null_constraints_result& operator=(const ThriftHiveMetastore_get_not_null_constraints_result&); + ThriftHiveMetastore_get_not_null_constraints_result() noexcept; + + virtual ~ThriftHiveMetastore_get_not_null_constraints_result() noexcept; + NotNullConstraintsResponse success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_not_null_constraints_result__isset __isset; + + void __set_success(const NotNullConstraintsResponse& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_not_null_constraints_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_not_null_constraints_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_not_null_constraints_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_not_null_constraints_presult__isset { + _ThriftHiveMetastore_get_not_null_constraints_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_not_null_constraints_presult__isset; + +class ThriftHiveMetastore_get_not_null_constraints_presult { + public: + + + virtual ~ThriftHiveMetastore_get_not_null_constraints_presult() noexcept; + NotNullConstraintsResponse* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_not_null_constraints_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_default_constraints_args__isset { + _ThriftHiveMetastore_get_default_constraints_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_default_constraints_args__isset; + +class ThriftHiveMetastore_get_default_constraints_args { + public: + + ThriftHiveMetastore_get_default_constraints_args(const ThriftHiveMetastore_get_default_constraints_args&); + ThriftHiveMetastore_get_default_constraints_args& operator=(const ThriftHiveMetastore_get_default_constraints_args&); + ThriftHiveMetastore_get_default_constraints_args() noexcept; + + virtual ~ThriftHiveMetastore_get_default_constraints_args() noexcept; + DefaultConstraintsRequest request; + + _ThriftHiveMetastore_get_default_constraints_args__isset __isset; + + void __set_request(const DefaultConstraintsRequest& val); + + bool operator == (const ThriftHiveMetastore_get_default_constraints_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_default_constraints_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_default_constraints_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_default_constraints_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_default_constraints_pargs() noexcept; + const DefaultConstraintsRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_default_constraints_result__isset { + _ThriftHiveMetastore_get_default_constraints_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_default_constraints_result__isset; + +class ThriftHiveMetastore_get_default_constraints_result { + public: + + ThriftHiveMetastore_get_default_constraints_result(const ThriftHiveMetastore_get_default_constraints_result&); + ThriftHiveMetastore_get_default_constraints_result& operator=(const ThriftHiveMetastore_get_default_constraints_result&); + ThriftHiveMetastore_get_default_constraints_result() noexcept; + + virtual ~ThriftHiveMetastore_get_default_constraints_result() noexcept; + DefaultConstraintsResponse success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_default_constraints_result__isset __isset; + + void __set_success(const DefaultConstraintsResponse& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_default_constraints_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_default_constraints_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_default_constraints_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_default_constraints_presult__isset { + _ThriftHiveMetastore_get_default_constraints_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_default_constraints_presult__isset; + +class ThriftHiveMetastore_get_default_constraints_presult { + public: + + + virtual ~ThriftHiveMetastore_get_default_constraints_presult() noexcept; + DefaultConstraintsResponse* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_default_constraints_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_check_constraints_args__isset { + _ThriftHiveMetastore_get_check_constraints_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_check_constraints_args__isset; + +class ThriftHiveMetastore_get_check_constraints_args { + public: + + ThriftHiveMetastore_get_check_constraints_args(const ThriftHiveMetastore_get_check_constraints_args&); + ThriftHiveMetastore_get_check_constraints_args& operator=(const ThriftHiveMetastore_get_check_constraints_args&); + ThriftHiveMetastore_get_check_constraints_args() noexcept; + + virtual ~ThriftHiveMetastore_get_check_constraints_args() noexcept; + CheckConstraintsRequest request; + + _ThriftHiveMetastore_get_check_constraints_args__isset __isset; + + void __set_request(const CheckConstraintsRequest& val); + + bool operator == (const ThriftHiveMetastore_get_check_constraints_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_check_constraints_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_check_constraints_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_check_constraints_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_check_constraints_pargs() noexcept; + const CheckConstraintsRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_check_constraints_result__isset { + _ThriftHiveMetastore_get_check_constraints_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_check_constraints_result__isset; + +class ThriftHiveMetastore_get_check_constraints_result { + public: + + ThriftHiveMetastore_get_check_constraints_result(const ThriftHiveMetastore_get_check_constraints_result&); + ThriftHiveMetastore_get_check_constraints_result& operator=(const ThriftHiveMetastore_get_check_constraints_result&); + ThriftHiveMetastore_get_check_constraints_result() noexcept; + + virtual ~ThriftHiveMetastore_get_check_constraints_result() noexcept; + CheckConstraintsResponse success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_check_constraints_result__isset __isset; + + void __set_success(const CheckConstraintsResponse& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_check_constraints_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_check_constraints_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_check_constraints_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_check_constraints_presult__isset { + _ThriftHiveMetastore_get_check_constraints_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_check_constraints_presult__isset; + +class ThriftHiveMetastore_get_check_constraints_presult { + public: + + + virtual ~ThriftHiveMetastore_get_check_constraints_presult() noexcept; + CheckConstraintsResponse* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_check_constraints_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_all_table_constraints_args__isset { + _ThriftHiveMetastore_get_all_table_constraints_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_all_table_constraints_args__isset; + +class ThriftHiveMetastore_get_all_table_constraints_args { + public: + + ThriftHiveMetastore_get_all_table_constraints_args(const ThriftHiveMetastore_get_all_table_constraints_args&); + ThriftHiveMetastore_get_all_table_constraints_args& operator=(const ThriftHiveMetastore_get_all_table_constraints_args&); + ThriftHiveMetastore_get_all_table_constraints_args() noexcept; + + virtual ~ThriftHiveMetastore_get_all_table_constraints_args() noexcept; + AllTableConstraintsRequest request; + + _ThriftHiveMetastore_get_all_table_constraints_args__isset __isset; + + void __set_request(const AllTableConstraintsRequest& val); + + bool operator == (const ThriftHiveMetastore_get_all_table_constraints_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_all_table_constraints_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_all_table_constraints_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_all_table_constraints_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_all_table_constraints_pargs() noexcept; + const AllTableConstraintsRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_all_table_constraints_result__isset { + _ThriftHiveMetastore_get_all_table_constraints_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_all_table_constraints_result__isset; + +class ThriftHiveMetastore_get_all_table_constraints_result { + public: + + ThriftHiveMetastore_get_all_table_constraints_result(const ThriftHiveMetastore_get_all_table_constraints_result&); + ThriftHiveMetastore_get_all_table_constraints_result& operator=(const ThriftHiveMetastore_get_all_table_constraints_result&); + ThriftHiveMetastore_get_all_table_constraints_result() noexcept; + + virtual ~ThriftHiveMetastore_get_all_table_constraints_result() noexcept; + AllTableConstraintsResponse success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_all_table_constraints_result__isset __isset; + + void __set_success(const AllTableConstraintsResponse& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_all_table_constraints_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_all_table_constraints_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_all_table_constraints_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_all_table_constraints_presult__isset { + _ThriftHiveMetastore_get_all_table_constraints_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_all_table_constraints_presult__isset; + +class ThriftHiveMetastore_get_all_table_constraints_presult { + public: + + + virtual ~ThriftHiveMetastore_get_all_table_constraints_presult() noexcept; + AllTableConstraintsResponse* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_all_table_constraints_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_update_table_column_statistics_args__isset { + _ThriftHiveMetastore_update_table_column_statistics_args__isset() : stats_obj(false) {} + bool stats_obj :1; +} _ThriftHiveMetastore_update_table_column_statistics_args__isset; + +class ThriftHiveMetastore_update_table_column_statistics_args { + public: + + ThriftHiveMetastore_update_table_column_statistics_args(const ThriftHiveMetastore_update_table_column_statistics_args&); + ThriftHiveMetastore_update_table_column_statistics_args& operator=(const ThriftHiveMetastore_update_table_column_statistics_args&); + ThriftHiveMetastore_update_table_column_statistics_args() noexcept; + + virtual ~ThriftHiveMetastore_update_table_column_statistics_args() noexcept; + ColumnStatistics stats_obj; + + _ThriftHiveMetastore_update_table_column_statistics_args__isset __isset; + + void __set_stats_obj(const ColumnStatistics& val); + + bool operator == (const ThriftHiveMetastore_update_table_column_statistics_args & rhs) const; + bool operator != (const ThriftHiveMetastore_update_table_column_statistics_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_update_table_column_statistics_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_update_table_column_statistics_pargs { + public: + + + virtual ~ThriftHiveMetastore_update_table_column_statistics_pargs() noexcept; + const ColumnStatistics* stats_obj; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_update_table_column_statistics_result__isset { + _ThriftHiveMetastore_update_table_column_statistics_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_update_table_column_statistics_result__isset; + +class ThriftHiveMetastore_update_table_column_statistics_result { + public: + + ThriftHiveMetastore_update_table_column_statistics_result(const ThriftHiveMetastore_update_table_column_statistics_result&); + ThriftHiveMetastore_update_table_column_statistics_result& operator=(const ThriftHiveMetastore_update_table_column_statistics_result&); + ThriftHiveMetastore_update_table_column_statistics_result() noexcept; + + virtual ~ThriftHiveMetastore_update_table_column_statistics_result() noexcept; + bool success; + NoSuchObjectException o1; + InvalidObjectException o2; + MetaException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_update_table_column_statistics_result__isset __isset; + + void __set_success(const bool val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const InvalidObjectException& val); + + void __set_o3(const MetaException& val); + + void __set_o4(const InvalidInputException& val); + + bool operator == (const ThriftHiveMetastore_update_table_column_statistics_result & rhs) const; + bool operator != (const ThriftHiveMetastore_update_table_column_statistics_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_update_table_column_statistics_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_update_table_column_statistics_presult__isset { + _ThriftHiveMetastore_update_table_column_statistics_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_update_table_column_statistics_presult__isset; + +class ThriftHiveMetastore_update_table_column_statistics_presult { + public: + + + virtual ~ThriftHiveMetastore_update_table_column_statistics_presult() noexcept; + bool* success; + NoSuchObjectException o1; + InvalidObjectException o2; + MetaException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_update_table_column_statistics_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_update_partition_column_statistics_args__isset { + _ThriftHiveMetastore_update_partition_column_statistics_args__isset() : stats_obj(false) {} + bool stats_obj :1; +} _ThriftHiveMetastore_update_partition_column_statistics_args__isset; + +class ThriftHiveMetastore_update_partition_column_statistics_args { + public: + + ThriftHiveMetastore_update_partition_column_statistics_args(const ThriftHiveMetastore_update_partition_column_statistics_args&); + ThriftHiveMetastore_update_partition_column_statistics_args& operator=(const ThriftHiveMetastore_update_partition_column_statistics_args&); + ThriftHiveMetastore_update_partition_column_statistics_args() noexcept; + + virtual ~ThriftHiveMetastore_update_partition_column_statistics_args() noexcept; + ColumnStatistics stats_obj; + + _ThriftHiveMetastore_update_partition_column_statistics_args__isset __isset; + + void __set_stats_obj(const ColumnStatistics& val); + + bool operator == (const ThriftHiveMetastore_update_partition_column_statistics_args & rhs) const; + bool operator != (const ThriftHiveMetastore_update_partition_column_statistics_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_update_partition_column_statistics_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_update_partition_column_statistics_pargs { + public: + + + virtual ~ThriftHiveMetastore_update_partition_column_statistics_pargs() noexcept; + const ColumnStatistics* stats_obj; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_update_partition_column_statistics_result__isset { + _ThriftHiveMetastore_update_partition_column_statistics_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_update_partition_column_statistics_result__isset; + +class ThriftHiveMetastore_update_partition_column_statistics_result { + public: + + ThriftHiveMetastore_update_partition_column_statistics_result(const ThriftHiveMetastore_update_partition_column_statistics_result&); + ThriftHiveMetastore_update_partition_column_statistics_result& operator=(const ThriftHiveMetastore_update_partition_column_statistics_result&); + ThriftHiveMetastore_update_partition_column_statistics_result() noexcept; + + virtual ~ThriftHiveMetastore_update_partition_column_statistics_result() noexcept; + bool success; + NoSuchObjectException o1; + InvalidObjectException o2; + MetaException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_update_partition_column_statistics_result__isset __isset; + + void __set_success(const bool val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const InvalidObjectException& val); + + void __set_o3(const MetaException& val); + + void __set_o4(const InvalidInputException& val); + + bool operator == (const ThriftHiveMetastore_update_partition_column_statistics_result & rhs) const; + bool operator != (const ThriftHiveMetastore_update_partition_column_statistics_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_update_partition_column_statistics_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_update_partition_column_statistics_presult__isset { + _ThriftHiveMetastore_update_partition_column_statistics_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_update_partition_column_statistics_presult__isset; + +class ThriftHiveMetastore_update_partition_column_statistics_presult { + public: + + + virtual ~ThriftHiveMetastore_update_partition_column_statistics_presult() noexcept; + bool* success; + NoSuchObjectException o1; + InvalidObjectException o2; + MetaException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_update_partition_column_statistics_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_update_table_column_statistics_req_args__isset { + _ThriftHiveMetastore_update_table_column_statistics_req_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_update_table_column_statistics_req_args__isset; + +class ThriftHiveMetastore_update_table_column_statistics_req_args { + public: + + ThriftHiveMetastore_update_table_column_statistics_req_args(const ThriftHiveMetastore_update_table_column_statistics_req_args&); + ThriftHiveMetastore_update_table_column_statistics_req_args& operator=(const ThriftHiveMetastore_update_table_column_statistics_req_args&); + ThriftHiveMetastore_update_table_column_statistics_req_args() noexcept; + + virtual ~ThriftHiveMetastore_update_table_column_statistics_req_args() noexcept; + SetPartitionsStatsRequest req; + + _ThriftHiveMetastore_update_table_column_statistics_req_args__isset __isset; + + void __set_req(const SetPartitionsStatsRequest& val); + + bool operator == (const ThriftHiveMetastore_update_table_column_statistics_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_update_table_column_statistics_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_update_table_column_statistics_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_update_table_column_statistics_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_update_table_column_statistics_req_pargs() noexcept; + const SetPartitionsStatsRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_update_table_column_statistics_req_result__isset { + _ThriftHiveMetastore_update_table_column_statistics_req_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_update_table_column_statistics_req_result__isset; + +class ThriftHiveMetastore_update_table_column_statistics_req_result { + public: + + ThriftHiveMetastore_update_table_column_statistics_req_result(const ThriftHiveMetastore_update_table_column_statistics_req_result&); + ThriftHiveMetastore_update_table_column_statistics_req_result& operator=(const ThriftHiveMetastore_update_table_column_statistics_req_result&); + ThriftHiveMetastore_update_table_column_statistics_req_result() noexcept; + + virtual ~ThriftHiveMetastore_update_table_column_statistics_req_result() noexcept; + SetPartitionsStatsResponse success; + NoSuchObjectException o1; + InvalidObjectException o2; + MetaException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_update_table_column_statistics_req_result__isset __isset; + + void __set_success(const SetPartitionsStatsResponse& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const InvalidObjectException& val); + + void __set_o3(const MetaException& val); + + void __set_o4(const InvalidInputException& val); + + bool operator == (const ThriftHiveMetastore_update_table_column_statistics_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_update_table_column_statistics_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_update_table_column_statistics_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_update_table_column_statistics_req_presult__isset { + _ThriftHiveMetastore_update_table_column_statistics_req_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_update_table_column_statistics_req_presult__isset; + +class ThriftHiveMetastore_update_table_column_statistics_req_presult { + public: + + + virtual ~ThriftHiveMetastore_update_table_column_statistics_req_presult() noexcept; + SetPartitionsStatsResponse* success; + NoSuchObjectException o1; + InvalidObjectException o2; + MetaException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_update_table_column_statistics_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_update_partition_column_statistics_req_args__isset { + _ThriftHiveMetastore_update_partition_column_statistics_req_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_update_partition_column_statistics_req_args__isset; + +class ThriftHiveMetastore_update_partition_column_statistics_req_args { + public: + + ThriftHiveMetastore_update_partition_column_statistics_req_args(const ThriftHiveMetastore_update_partition_column_statistics_req_args&); + ThriftHiveMetastore_update_partition_column_statistics_req_args& operator=(const ThriftHiveMetastore_update_partition_column_statistics_req_args&); + ThriftHiveMetastore_update_partition_column_statistics_req_args() noexcept; + + virtual ~ThriftHiveMetastore_update_partition_column_statistics_req_args() noexcept; + SetPartitionsStatsRequest req; + + _ThriftHiveMetastore_update_partition_column_statistics_req_args__isset __isset; + + void __set_req(const SetPartitionsStatsRequest& val); + + bool operator == (const ThriftHiveMetastore_update_partition_column_statistics_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_update_partition_column_statistics_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_update_partition_column_statistics_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_update_partition_column_statistics_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_update_partition_column_statistics_req_pargs() noexcept; + const SetPartitionsStatsRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_update_partition_column_statistics_req_result__isset { + _ThriftHiveMetastore_update_partition_column_statistics_req_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_update_partition_column_statistics_req_result__isset; + +class ThriftHiveMetastore_update_partition_column_statistics_req_result { + public: + + ThriftHiveMetastore_update_partition_column_statistics_req_result(const ThriftHiveMetastore_update_partition_column_statistics_req_result&); + ThriftHiveMetastore_update_partition_column_statistics_req_result& operator=(const ThriftHiveMetastore_update_partition_column_statistics_req_result&); + ThriftHiveMetastore_update_partition_column_statistics_req_result() noexcept; + + virtual ~ThriftHiveMetastore_update_partition_column_statistics_req_result() noexcept; + SetPartitionsStatsResponse success; + NoSuchObjectException o1; + InvalidObjectException o2; + MetaException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_update_partition_column_statistics_req_result__isset __isset; + + void __set_success(const SetPartitionsStatsResponse& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const InvalidObjectException& val); + + void __set_o3(const MetaException& val); + + void __set_o4(const InvalidInputException& val); + + bool operator == (const ThriftHiveMetastore_update_partition_column_statistics_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_update_partition_column_statistics_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_update_partition_column_statistics_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_update_partition_column_statistics_req_presult__isset { + _ThriftHiveMetastore_update_partition_column_statistics_req_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_update_partition_column_statistics_req_presult__isset; + +class ThriftHiveMetastore_update_partition_column_statistics_req_presult { + public: + + + virtual ~ThriftHiveMetastore_update_partition_column_statistics_req_presult() noexcept; + SetPartitionsStatsResponse* success; + NoSuchObjectException o1; + InvalidObjectException o2; + MetaException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_update_partition_column_statistics_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_update_transaction_statistics_args__isset { + _ThriftHiveMetastore_update_transaction_statistics_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_update_transaction_statistics_args__isset; + +class ThriftHiveMetastore_update_transaction_statistics_args { + public: + + ThriftHiveMetastore_update_transaction_statistics_args(const ThriftHiveMetastore_update_transaction_statistics_args&) noexcept; + ThriftHiveMetastore_update_transaction_statistics_args& operator=(const ThriftHiveMetastore_update_transaction_statistics_args&) noexcept; + ThriftHiveMetastore_update_transaction_statistics_args() noexcept; + + virtual ~ThriftHiveMetastore_update_transaction_statistics_args() noexcept; + UpdateTransactionalStatsRequest req; + + _ThriftHiveMetastore_update_transaction_statistics_args__isset __isset; + + void __set_req(const UpdateTransactionalStatsRequest& val); + + bool operator == (const ThriftHiveMetastore_update_transaction_statistics_args & rhs) const; + bool operator != (const ThriftHiveMetastore_update_transaction_statistics_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_update_transaction_statistics_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_update_transaction_statistics_pargs { + public: + + + virtual ~ThriftHiveMetastore_update_transaction_statistics_pargs() noexcept; + const UpdateTransactionalStatsRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_update_transaction_statistics_result__isset { + _ThriftHiveMetastore_update_transaction_statistics_result__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_update_transaction_statistics_result__isset; + +class ThriftHiveMetastore_update_transaction_statistics_result { + public: + + ThriftHiveMetastore_update_transaction_statistics_result(const ThriftHiveMetastore_update_transaction_statistics_result&); + ThriftHiveMetastore_update_transaction_statistics_result& operator=(const ThriftHiveMetastore_update_transaction_statistics_result&); + ThriftHiveMetastore_update_transaction_statistics_result() noexcept; + + virtual ~ThriftHiveMetastore_update_transaction_statistics_result() noexcept; + MetaException o1; + + _ThriftHiveMetastore_update_transaction_statistics_result__isset __isset; + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_update_transaction_statistics_result & rhs) const; + bool operator != (const ThriftHiveMetastore_update_transaction_statistics_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_update_transaction_statistics_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_update_transaction_statistics_presult__isset { + _ThriftHiveMetastore_update_transaction_statistics_presult__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_update_transaction_statistics_presult__isset; + +class ThriftHiveMetastore_update_transaction_statistics_presult { + public: + + + virtual ~ThriftHiveMetastore_update_transaction_statistics_presult() noexcept; + MetaException o1; + + _ThriftHiveMetastore_update_transaction_statistics_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_table_column_statistics_args__isset { + _ThriftHiveMetastore_get_table_column_statistics_args__isset() : db_name(false), tbl_name(false), col_name(false) {} + bool db_name :1; + bool tbl_name :1; + bool col_name :1; +} _ThriftHiveMetastore_get_table_column_statistics_args__isset; + +class ThriftHiveMetastore_get_table_column_statistics_args { + public: + + ThriftHiveMetastore_get_table_column_statistics_args(const ThriftHiveMetastore_get_table_column_statistics_args&); + ThriftHiveMetastore_get_table_column_statistics_args& operator=(const ThriftHiveMetastore_get_table_column_statistics_args&); + ThriftHiveMetastore_get_table_column_statistics_args() noexcept; + + virtual ~ThriftHiveMetastore_get_table_column_statistics_args() noexcept; + std::string db_name; + std::string tbl_name; + std::string col_name; + + _ThriftHiveMetastore_get_table_column_statistics_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_col_name(const std::string& val); + + bool operator == (const ThriftHiveMetastore_get_table_column_statistics_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_table_column_statistics_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_table_column_statistics_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_table_column_statistics_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_table_column_statistics_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::string* col_name; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_table_column_statistics_result__isset { + _ThriftHiveMetastore_get_table_column_statistics_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_get_table_column_statistics_result__isset; + +class ThriftHiveMetastore_get_table_column_statistics_result { + public: + + ThriftHiveMetastore_get_table_column_statistics_result(const ThriftHiveMetastore_get_table_column_statistics_result&); + ThriftHiveMetastore_get_table_column_statistics_result& operator=(const ThriftHiveMetastore_get_table_column_statistics_result&); + ThriftHiveMetastore_get_table_column_statistics_result() noexcept; + + virtual ~ThriftHiveMetastore_get_table_column_statistics_result() noexcept; + ColumnStatistics success; + NoSuchObjectException o1; + MetaException o2; + InvalidInputException o3; + InvalidObjectException o4; + + _ThriftHiveMetastore_get_table_column_statistics_result__isset __isset; + + void __set_success(const ColumnStatistics& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + void __set_o3(const InvalidInputException& val); + + void __set_o4(const InvalidObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_table_column_statistics_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_table_column_statistics_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_table_column_statistics_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_table_column_statistics_presult__isset { + _ThriftHiveMetastore_get_table_column_statistics_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_get_table_column_statistics_presult__isset; + +class ThriftHiveMetastore_get_table_column_statistics_presult { + public: + + + virtual ~ThriftHiveMetastore_get_table_column_statistics_presult() noexcept; + ColumnStatistics* success; + NoSuchObjectException o1; + MetaException o2; + InvalidInputException o3; + InvalidObjectException o4; + + _ThriftHiveMetastore_get_table_column_statistics_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partition_column_statistics_args__isset { + _ThriftHiveMetastore_get_partition_column_statistics_args__isset() : db_name(false), tbl_name(false), part_name(false), col_name(false) {} + bool db_name :1; + bool tbl_name :1; + bool part_name :1; + bool col_name :1; +} _ThriftHiveMetastore_get_partition_column_statistics_args__isset; + +class ThriftHiveMetastore_get_partition_column_statistics_args { + public: + + ThriftHiveMetastore_get_partition_column_statistics_args(const ThriftHiveMetastore_get_partition_column_statistics_args&); + ThriftHiveMetastore_get_partition_column_statistics_args& operator=(const ThriftHiveMetastore_get_partition_column_statistics_args&); + ThriftHiveMetastore_get_partition_column_statistics_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partition_column_statistics_args() noexcept; + std::string db_name; + std::string tbl_name; + std::string part_name; + std::string col_name; + + _ThriftHiveMetastore_get_partition_column_statistics_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_part_name(const std::string& val); + + void __set_col_name(const std::string& val); + + bool operator == (const ThriftHiveMetastore_get_partition_column_statistics_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partition_column_statistics_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partition_column_statistics_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partition_column_statistics_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partition_column_statistics_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::string* part_name; + const std::string* col_name; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partition_column_statistics_result__isset { + _ThriftHiveMetastore_get_partition_column_statistics_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_get_partition_column_statistics_result__isset; + +class ThriftHiveMetastore_get_partition_column_statistics_result { + public: + + ThriftHiveMetastore_get_partition_column_statistics_result(const ThriftHiveMetastore_get_partition_column_statistics_result&); + ThriftHiveMetastore_get_partition_column_statistics_result& operator=(const ThriftHiveMetastore_get_partition_column_statistics_result&); + ThriftHiveMetastore_get_partition_column_statistics_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partition_column_statistics_result() noexcept; + ColumnStatistics success; + NoSuchObjectException o1; + MetaException o2; + InvalidInputException o3; + InvalidObjectException o4; + + _ThriftHiveMetastore_get_partition_column_statistics_result__isset __isset; + + void __set_success(const ColumnStatistics& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + void __set_o3(const InvalidInputException& val); + + void __set_o4(const InvalidObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_partition_column_statistics_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partition_column_statistics_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partition_column_statistics_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partition_column_statistics_presult__isset { + _ThriftHiveMetastore_get_partition_column_statistics_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_get_partition_column_statistics_presult__isset; + +class ThriftHiveMetastore_get_partition_column_statistics_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partition_column_statistics_presult() noexcept; + ColumnStatistics* success; + NoSuchObjectException o1; + MetaException o2; + InvalidInputException o3; + InvalidObjectException o4; + + _ThriftHiveMetastore_get_partition_column_statistics_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_table_statistics_req_args__isset { + _ThriftHiveMetastore_get_table_statistics_req_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_table_statistics_req_args__isset; + +class ThriftHiveMetastore_get_table_statistics_req_args { + public: + + ThriftHiveMetastore_get_table_statistics_req_args(const ThriftHiveMetastore_get_table_statistics_req_args&); + ThriftHiveMetastore_get_table_statistics_req_args& operator=(const ThriftHiveMetastore_get_table_statistics_req_args&); + ThriftHiveMetastore_get_table_statistics_req_args() noexcept; + + virtual ~ThriftHiveMetastore_get_table_statistics_req_args() noexcept; + TableStatsRequest request; + + _ThriftHiveMetastore_get_table_statistics_req_args__isset __isset; + + void __set_request(const TableStatsRequest& val); + + bool operator == (const ThriftHiveMetastore_get_table_statistics_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_table_statistics_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_table_statistics_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_table_statistics_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_table_statistics_req_pargs() noexcept; + const TableStatsRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_table_statistics_req_result__isset { + _ThriftHiveMetastore_get_table_statistics_req_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_table_statistics_req_result__isset; + +class ThriftHiveMetastore_get_table_statistics_req_result { + public: + + ThriftHiveMetastore_get_table_statistics_req_result(const ThriftHiveMetastore_get_table_statistics_req_result&); + ThriftHiveMetastore_get_table_statistics_req_result& operator=(const ThriftHiveMetastore_get_table_statistics_req_result&); + ThriftHiveMetastore_get_table_statistics_req_result() noexcept; + + virtual ~ThriftHiveMetastore_get_table_statistics_req_result() noexcept; + TableStatsResult success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_table_statistics_req_result__isset __isset; + + void __set_success(const TableStatsResult& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_table_statistics_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_table_statistics_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_table_statistics_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_table_statistics_req_presult__isset { + _ThriftHiveMetastore_get_table_statistics_req_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_table_statistics_req_presult__isset; + +class ThriftHiveMetastore_get_table_statistics_req_presult { + public: + + + virtual ~ThriftHiveMetastore_get_table_statistics_req_presult() noexcept; + TableStatsResult* success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_table_statistics_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_statistics_req_args__isset { + _ThriftHiveMetastore_get_partitions_statistics_req_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_partitions_statistics_req_args__isset; + +class ThriftHiveMetastore_get_partitions_statistics_req_args { + public: + + ThriftHiveMetastore_get_partitions_statistics_req_args(const ThriftHiveMetastore_get_partitions_statistics_req_args&); + ThriftHiveMetastore_get_partitions_statistics_req_args& operator=(const ThriftHiveMetastore_get_partitions_statistics_req_args&); + ThriftHiveMetastore_get_partitions_statistics_req_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_statistics_req_args() noexcept; + PartitionsStatsRequest request; + + _ThriftHiveMetastore_get_partitions_statistics_req_args__isset __isset; + + void __set_request(const PartitionsStatsRequest& val); + + bool operator == (const ThriftHiveMetastore_get_partitions_statistics_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_statistics_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_statistics_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partitions_statistics_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_statistics_req_pargs() noexcept; + const PartitionsStatsRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_statistics_req_result__isset { + _ThriftHiveMetastore_get_partitions_statistics_req_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_statistics_req_result__isset; + +class ThriftHiveMetastore_get_partitions_statistics_req_result { + public: + + ThriftHiveMetastore_get_partitions_statistics_req_result(const ThriftHiveMetastore_get_partitions_statistics_req_result&); + ThriftHiveMetastore_get_partitions_statistics_req_result& operator=(const ThriftHiveMetastore_get_partitions_statistics_req_result&); + ThriftHiveMetastore_get_partitions_statistics_req_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_statistics_req_result() noexcept; + PartitionsStatsResult success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_partitions_statistics_req_result__isset __isset; + + void __set_success(const PartitionsStatsResult& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_partitions_statistics_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_statistics_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_statistics_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_statistics_req_presult__isset { + _ThriftHiveMetastore_get_partitions_statistics_req_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_partitions_statistics_req_presult__isset; + +class ThriftHiveMetastore_get_partitions_statistics_req_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_statistics_req_presult() noexcept; + PartitionsStatsResult* success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_partitions_statistics_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_aggr_stats_for_args__isset { + _ThriftHiveMetastore_get_aggr_stats_for_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_aggr_stats_for_args__isset; + +class ThriftHiveMetastore_get_aggr_stats_for_args { + public: + + ThriftHiveMetastore_get_aggr_stats_for_args(const ThriftHiveMetastore_get_aggr_stats_for_args&); + ThriftHiveMetastore_get_aggr_stats_for_args& operator=(const ThriftHiveMetastore_get_aggr_stats_for_args&); + ThriftHiveMetastore_get_aggr_stats_for_args() noexcept; + + virtual ~ThriftHiveMetastore_get_aggr_stats_for_args() noexcept; + PartitionsStatsRequest request; + + _ThriftHiveMetastore_get_aggr_stats_for_args__isset __isset; + + void __set_request(const PartitionsStatsRequest& val); + + bool operator == (const ThriftHiveMetastore_get_aggr_stats_for_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_aggr_stats_for_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_aggr_stats_for_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_aggr_stats_for_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_aggr_stats_for_pargs() noexcept; + const PartitionsStatsRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_aggr_stats_for_result__isset { + _ThriftHiveMetastore_get_aggr_stats_for_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_aggr_stats_for_result__isset; + +class ThriftHiveMetastore_get_aggr_stats_for_result { + public: + + ThriftHiveMetastore_get_aggr_stats_for_result(const ThriftHiveMetastore_get_aggr_stats_for_result&); + ThriftHiveMetastore_get_aggr_stats_for_result& operator=(const ThriftHiveMetastore_get_aggr_stats_for_result&); + ThriftHiveMetastore_get_aggr_stats_for_result() noexcept; + + virtual ~ThriftHiveMetastore_get_aggr_stats_for_result() noexcept; + AggrStats success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_aggr_stats_for_result__isset __isset; + + void __set_success(const AggrStats& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_aggr_stats_for_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_aggr_stats_for_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_aggr_stats_for_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_aggr_stats_for_presult__isset { + _ThriftHiveMetastore_get_aggr_stats_for_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_aggr_stats_for_presult__isset; + +class ThriftHiveMetastore_get_aggr_stats_for_presult { + public: + + + virtual ~ThriftHiveMetastore_get_aggr_stats_for_presult() noexcept; + AggrStats* success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_aggr_stats_for_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_set_aggr_stats_for_args__isset { + _ThriftHiveMetastore_set_aggr_stats_for_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_set_aggr_stats_for_args__isset; + +class ThriftHiveMetastore_set_aggr_stats_for_args { + public: + + ThriftHiveMetastore_set_aggr_stats_for_args(const ThriftHiveMetastore_set_aggr_stats_for_args&); + ThriftHiveMetastore_set_aggr_stats_for_args& operator=(const ThriftHiveMetastore_set_aggr_stats_for_args&); + ThriftHiveMetastore_set_aggr_stats_for_args() noexcept; + + virtual ~ThriftHiveMetastore_set_aggr_stats_for_args() noexcept; + SetPartitionsStatsRequest request; + + _ThriftHiveMetastore_set_aggr_stats_for_args__isset __isset; + + void __set_request(const SetPartitionsStatsRequest& val); + + bool operator == (const ThriftHiveMetastore_set_aggr_stats_for_args & rhs) const; + bool operator != (const ThriftHiveMetastore_set_aggr_stats_for_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_set_aggr_stats_for_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_set_aggr_stats_for_pargs { + public: + + + virtual ~ThriftHiveMetastore_set_aggr_stats_for_pargs() noexcept; + const SetPartitionsStatsRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_set_aggr_stats_for_result__isset { + _ThriftHiveMetastore_set_aggr_stats_for_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_set_aggr_stats_for_result__isset; + +class ThriftHiveMetastore_set_aggr_stats_for_result { + public: + + ThriftHiveMetastore_set_aggr_stats_for_result(const ThriftHiveMetastore_set_aggr_stats_for_result&); + ThriftHiveMetastore_set_aggr_stats_for_result& operator=(const ThriftHiveMetastore_set_aggr_stats_for_result&); + ThriftHiveMetastore_set_aggr_stats_for_result() noexcept; + + virtual ~ThriftHiveMetastore_set_aggr_stats_for_result() noexcept; + bool success; + NoSuchObjectException o1; + InvalidObjectException o2; + MetaException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_set_aggr_stats_for_result__isset __isset; + + void __set_success(const bool val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const InvalidObjectException& val); + + void __set_o3(const MetaException& val); + + void __set_o4(const InvalidInputException& val); + + bool operator == (const ThriftHiveMetastore_set_aggr_stats_for_result & rhs) const; + bool operator != (const ThriftHiveMetastore_set_aggr_stats_for_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_set_aggr_stats_for_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_set_aggr_stats_for_presult__isset { + _ThriftHiveMetastore_set_aggr_stats_for_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_set_aggr_stats_for_presult__isset; + +class ThriftHiveMetastore_set_aggr_stats_for_presult { + public: + + + virtual ~ThriftHiveMetastore_set_aggr_stats_for_presult() noexcept; + bool* success; + NoSuchObjectException o1; + InvalidObjectException o2; + MetaException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_set_aggr_stats_for_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_delete_partition_column_statistics_args__isset { + _ThriftHiveMetastore_delete_partition_column_statistics_args__isset() : db_name(false), tbl_name(false), part_name(false), col_name(false), engine(false) {} + bool db_name :1; + bool tbl_name :1; + bool part_name :1; + bool col_name :1; + bool engine :1; +} _ThriftHiveMetastore_delete_partition_column_statistics_args__isset; + +class ThriftHiveMetastore_delete_partition_column_statistics_args { + public: + + ThriftHiveMetastore_delete_partition_column_statistics_args(const ThriftHiveMetastore_delete_partition_column_statistics_args&); + ThriftHiveMetastore_delete_partition_column_statistics_args& operator=(const ThriftHiveMetastore_delete_partition_column_statistics_args&); + ThriftHiveMetastore_delete_partition_column_statistics_args() noexcept; + + virtual ~ThriftHiveMetastore_delete_partition_column_statistics_args() noexcept; + std::string db_name; + std::string tbl_name; + std::string part_name; + std::string col_name; + std::string engine; + + _ThriftHiveMetastore_delete_partition_column_statistics_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_part_name(const std::string& val); + + void __set_col_name(const std::string& val); + + void __set_engine(const std::string& val); + + bool operator == (const ThriftHiveMetastore_delete_partition_column_statistics_args & rhs) const; + bool operator != (const ThriftHiveMetastore_delete_partition_column_statistics_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_delete_partition_column_statistics_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_delete_partition_column_statistics_pargs { + public: + + + virtual ~ThriftHiveMetastore_delete_partition_column_statistics_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::string* part_name; + const std::string* col_name; + const std::string* engine; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_delete_partition_column_statistics_result__isset { + _ThriftHiveMetastore_delete_partition_column_statistics_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_delete_partition_column_statistics_result__isset; + +class ThriftHiveMetastore_delete_partition_column_statistics_result { + public: + + ThriftHiveMetastore_delete_partition_column_statistics_result(const ThriftHiveMetastore_delete_partition_column_statistics_result&); + ThriftHiveMetastore_delete_partition_column_statistics_result& operator=(const ThriftHiveMetastore_delete_partition_column_statistics_result&); + ThriftHiveMetastore_delete_partition_column_statistics_result() noexcept; + + virtual ~ThriftHiveMetastore_delete_partition_column_statistics_result() noexcept; + bool success; + NoSuchObjectException o1; + MetaException o2; + InvalidObjectException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_delete_partition_column_statistics_result__isset __isset; + + void __set_success(const bool val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + void __set_o3(const InvalidObjectException& val); + + void __set_o4(const InvalidInputException& val); + + bool operator == (const ThriftHiveMetastore_delete_partition_column_statistics_result & rhs) const; + bool operator != (const ThriftHiveMetastore_delete_partition_column_statistics_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_delete_partition_column_statistics_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_delete_partition_column_statistics_presult__isset { + _ThriftHiveMetastore_delete_partition_column_statistics_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_delete_partition_column_statistics_presult__isset; + +class ThriftHiveMetastore_delete_partition_column_statistics_presult { + public: + + + virtual ~ThriftHiveMetastore_delete_partition_column_statistics_presult() noexcept; + bool* success; + NoSuchObjectException o1; + MetaException o2; + InvalidObjectException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_delete_partition_column_statistics_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_delete_table_column_statistics_args__isset { + _ThriftHiveMetastore_delete_table_column_statistics_args__isset() : db_name(false), tbl_name(false), col_name(false), engine(false) {} + bool db_name :1; + bool tbl_name :1; + bool col_name :1; + bool engine :1; +} _ThriftHiveMetastore_delete_table_column_statistics_args__isset; + +class ThriftHiveMetastore_delete_table_column_statistics_args { + public: + + ThriftHiveMetastore_delete_table_column_statistics_args(const ThriftHiveMetastore_delete_table_column_statistics_args&); + ThriftHiveMetastore_delete_table_column_statistics_args& operator=(const ThriftHiveMetastore_delete_table_column_statistics_args&); + ThriftHiveMetastore_delete_table_column_statistics_args() noexcept; + + virtual ~ThriftHiveMetastore_delete_table_column_statistics_args() noexcept; + std::string db_name; + std::string tbl_name; + std::string col_name; + std::string engine; + + _ThriftHiveMetastore_delete_table_column_statistics_args__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_col_name(const std::string& val); + + void __set_engine(const std::string& val); + + bool operator == (const ThriftHiveMetastore_delete_table_column_statistics_args & rhs) const; + bool operator != (const ThriftHiveMetastore_delete_table_column_statistics_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_delete_table_column_statistics_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_delete_table_column_statistics_pargs { + public: + + + virtual ~ThriftHiveMetastore_delete_table_column_statistics_pargs() noexcept; + const std::string* db_name; + const std::string* tbl_name; + const std::string* col_name; + const std::string* engine; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_delete_table_column_statistics_result__isset { + _ThriftHiveMetastore_delete_table_column_statistics_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_delete_table_column_statistics_result__isset; + +class ThriftHiveMetastore_delete_table_column_statistics_result { + public: + + ThriftHiveMetastore_delete_table_column_statistics_result(const ThriftHiveMetastore_delete_table_column_statistics_result&); + ThriftHiveMetastore_delete_table_column_statistics_result& operator=(const ThriftHiveMetastore_delete_table_column_statistics_result&); + ThriftHiveMetastore_delete_table_column_statistics_result() noexcept; + + virtual ~ThriftHiveMetastore_delete_table_column_statistics_result() noexcept; + bool success; + NoSuchObjectException o1; + MetaException o2; + InvalidObjectException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_delete_table_column_statistics_result__isset __isset; + + void __set_success(const bool val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + void __set_o3(const InvalidObjectException& val); + + void __set_o4(const InvalidInputException& val); + + bool operator == (const ThriftHiveMetastore_delete_table_column_statistics_result & rhs) const; + bool operator != (const ThriftHiveMetastore_delete_table_column_statistics_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_delete_table_column_statistics_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_delete_table_column_statistics_presult__isset { + _ThriftHiveMetastore_delete_table_column_statistics_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_delete_table_column_statistics_presult__isset; + +class ThriftHiveMetastore_delete_table_column_statistics_presult { + public: + + + virtual ~ThriftHiveMetastore_delete_table_column_statistics_presult() noexcept; + bool* success; + NoSuchObjectException o1; + MetaException o2; + InvalidObjectException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_delete_table_column_statistics_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_create_function_args__isset { + _ThriftHiveMetastore_create_function_args__isset() : func(false) {} + bool func :1; +} _ThriftHiveMetastore_create_function_args__isset; + +class ThriftHiveMetastore_create_function_args { + public: + + ThriftHiveMetastore_create_function_args(const ThriftHiveMetastore_create_function_args&); + ThriftHiveMetastore_create_function_args& operator=(const ThriftHiveMetastore_create_function_args&); + ThriftHiveMetastore_create_function_args() noexcept; + + virtual ~ThriftHiveMetastore_create_function_args() noexcept; + Function func; + + _ThriftHiveMetastore_create_function_args__isset __isset; + + void __set_func(const Function& val); + + bool operator == (const ThriftHiveMetastore_create_function_args & rhs) const; + bool operator != (const ThriftHiveMetastore_create_function_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_function_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_create_function_pargs { + public: + + + virtual ~ThriftHiveMetastore_create_function_pargs() noexcept; + const Function* func; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_function_result__isset { + _ThriftHiveMetastore_create_function_result__isset() : o1(false), o2(false), o3(false), o4(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_create_function_result__isset; + +class ThriftHiveMetastore_create_function_result { + public: + + ThriftHiveMetastore_create_function_result(const ThriftHiveMetastore_create_function_result&); + ThriftHiveMetastore_create_function_result& operator=(const ThriftHiveMetastore_create_function_result&); + ThriftHiveMetastore_create_function_result() noexcept; + + virtual ~ThriftHiveMetastore_create_function_result() noexcept; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + NoSuchObjectException o4; + + _ThriftHiveMetastore_create_function_result__isset __isset; + + void __set_o1(const AlreadyExistsException& val); + + void __set_o2(const InvalidObjectException& val); + + void __set_o3(const MetaException& val); + + void __set_o4(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_create_function_result & rhs) const; + bool operator != (const ThriftHiveMetastore_create_function_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_function_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_function_presult__isset { + _ThriftHiveMetastore_create_function_presult__isset() : o1(false), o2(false), o3(false), o4(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_create_function_presult__isset; + +class ThriftHiveMetastore_create_function_presult { + public: + + + virtual ~ThriftHiveMetastore_create_function_presult() noexcept; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + NoSuchObjectException o4; + + _ThriftHiveMetastore_create_function_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_function_args__isset { + _ThriftHiveMetastore_drop_function_args__isset() : dbName(false), funcName(false) {} + bool dbName :1; + bool funcName :1; +} _ThriftHiveMetastore_drop_function_args__isset; + +class ThriftHiveMetastore_drop_function_args { + public: + + ThriftHiveMetastore_drop_function_args(const ThriftHiveMetastore_drop_function_args&); + ThriftHiveMetastore_drop_function_args& operator=(const ThriftHiveMetastore_drop_function_args&); + ThriftHiveMetastore_drop_function_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_function_args() noexcept; + std::string dbName; + std::string funcName; + + _ThriftHiveMetastore_drop_function_args__isset __isset; + + void __set_dbName(const std::string& val); + + void __set_funcName(const std::string& val); + + bool operator == (const ThriftHiveMetastore_drop_function_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_function_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_function_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_function_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_function_pargs() noexcept; + const std::string* dbName; + const std::string* funcName; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_function_result__isset { + _ThriftHiveMetastore_drop_function_result__isset() : o1(false), o3(false) {} + bool o1 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_function_result__isset; + +class ThriftHiveMetastore_drop_function_result { + public: + + ThriftHiveMetastore_drop_function_result(const ThriftHiveMetastore_drop_function_result&); + ThriftHiveMetastore_drop_function_result& operator=(const ThriftHiveMetastore_drop_function_result&); + ThriftHiveMetastore_drop_function_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_function_result() noexcept; + NoSuchObjectException o1; + MetaException o3; + + _ThriftHiveMetastore_drop_function_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_function_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_function_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_function_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_function_presult__isset { + _ThriftHiveMetastore_drop_function_presult__isset() : o1(false), o3(false) {} + bool o1 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_function_presult__isset; + +class ThriftHiveMetastore_drop_function_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_function_presult() noexcept; + NoSuchObjectException o1; + MetaException o3; + + _ThriftHiveMetastore_drop_function_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_alter_function_args__isset { + _ThriftHiveMetastore_alter_function_args__isset() : dbName(false), funcName(false), newFunc(false) {} + bool dbName :1; + bool funcName :1; + bool newFunc :1; +} _ThriftHiveMetastore_alter_function_args__isset; + +class ThriftHiveMetastore_alter_function_args { + public: + + ThriftHiveMetastore_alter_function_args(const ThriftHiveMetastore_alter_function_args&); + ThriftHiveMetastore_alter_function_args& operator=(const ThriftHiveMetastore_alter_function_args&); + ThriftHiveMetastore_alter_function_args() noexcept; + + virtual ~ThriftHiveMetastore_alter_function_args() noexcept; + std::string dbName; + std::string funcName; + Function newFunc; + + _ThriftHiveMetastore_alter_function_args__isset __isset; + + void __set_dbName(const std::string& val); + + void __set_funcName(const std::string& val); + + void __set_newFunc(const Function& val); + + bool operator == (const ThriftHiveMetastore_alter_function_args & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_function_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_function_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_alter_function_pargs { + public: + + + virtual ~ThriftHiveMetastore_alter_function_pargs() noexcept; + const std::string* dbName; + const std::string* funcName; + const Function* newFunc; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_function_result__isset { + _ThriftHiveMetastore_alter_function_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_function_result__isset; + +class ThriftHiveMetastore_alter_function_result { + public: + + ThriftHiveMetastore_alter_function_result(const ThriftHiveMetastore_alter_function_result&); + ThriftHiveMetastore_alter_function_result& operator=(const ThriftHiveMetastore_alter_function_result&); + ThriftHiveMetastore_alter_function_result() noexcept; + + virtual ~ThriftHiveMetastore_alter_function_result() noexcept; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_function_result__isset __isset; + + void __set_o1(const InvalidOperationException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_alter_function_result & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_function_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_function_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_function_presult__isset { + _ThriftHiveMetastore_alter_function_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_function_presult__isset; + +class ThriftHiveMetastore_alter_function_presult { + public: + + + virtual ~ThriftHiveMetastore_alter_function_presult() noexcept; + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_function_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_functions_args__isset { + _ThriftHiveMetastore_get_functions_args__isset() : dbName(false), pattern(false) {} + bool dbName :1; + bool pattern :1; +} _ThriftHiveMetastore_get_functions_args__isset; + +class ThriftHiveMetastore_get_functions_args { + public: + + ThriftHiveMetastore_get_functions_args(const ThriftHiveMetastore_get_functions_args&); + ThriftHiveMetastore_get_functions_args& operator=(const ThriftHiveMetastore_get_functions_args&); + ThriftHiveMetastore_get_functions_args() noexcept; + + virtual ~ThriftHiveMetastore_get_functions_args() noexcept; + std::string dbName; + std::string pattern; + + _ThriftHiveMetastore_get_functions_args__isset __isset; + + void __set_dbName(const std::string& val); + + void __set_pattern(const std::string& val); + + bool operator == (const ThriftHiveMetastore_get_functions_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_functions_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_functions_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_functions_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_functions_pargs() noexcept; + const std::string* dbName; + const std::string* pattern; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_functions_result__isset { + _ThriftHiveMetastore_get_functions_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_functions_result__isset; + +class ThriftHiveMetastore_get_functions_result { + public: + + ThriftHiveMetastore_get_functions_result(const ThriftHiveMetastore_get_functions_result&); + ThriftHiveMetastore_get_functions_result& operator=(const ThriftHiveMetastore_get_functions_result&); + ThriftHiveMetastore_get_functions_result() noexcept; + + virtual ~ThriftHiveMetastore_get_functions_result() noexcept; + std::vector success; + MetaException o1; + + _ThriftHiveMetastore_get_functions_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_functions_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_functions_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_functions_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_functions_presult__isset { + _ThriftHiveMetastore_get_functions_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_functions_presult__isset; + +class ThriftHiveMetastore_get_functions_presult { + public: + + + virtual ~ThriftHiveMetastore_get_functions_presult() noexcept; + std::vector * success; + MetaException o1; + + _ThriftHiveMetastore_get_functions_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_function_args__isset { + _ThriftHiveMetastore_get_function_args__isset() : dbName(false), funcName(false) {} + bool dbName :1; + bool funcName :1; +} _ThriftHiveMetastore_get_function_args__isset; + +class ThriftHiveMetastore_get_function_args { + public: + + ThriftHiveMetastore_get_function_args(const ThriftHiveMetastore_get_function_args&); + ThriftHiveMetastore_get_function_args& operator=(const ThriftHiveMetastore_get_function_args&); + ThriftHiveMetastore_get_function_args() noexcept; + + virtual ~ThriftHiveMetastore_get_function_args() noexcept; + std::string dbName; + std::string funcName; + + _ThriftHiveMetastore_get_function_args__isset __isset; + + void __set_dbName(const std::string& val); + + void __set_funcName(const std::string& val); + + bool operator == (const ThriftHiveMetastore_get_function_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_function_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_function_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_function_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_function_pargs() noexcept; + const std::string* dbName; + const std::string* funcName; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_function_result__isset { + _ThriftHiveMetastore_get_function_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_function_result__isset; + +class ThriftHiveMetastore_get_function_result { + public: + + ThriftHiveMetastore_get_function_result(const ThriftHiveMetastore_get_function_result&); + ThriftHiveMetastore_get_function_result& operator=(const ThriftHiveMetastore_get_function_result&); + ThriftHiveMetastore_get_function_result() noexcept; + + virtual ~ThriftHiveMetastore_get_function_result() noexcept; + Function success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_function_result__isset __isset; + + void __set_success(const Function& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_function_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_function_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_function_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_function_presult__isset { + _ThriftHiveMetastore_get_function_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_function_presult__isset; + +class ThriftHiveMetastore_get_function_presult { + public: + + + virtual ~ThriftHiveMetastore_get_function_presult() noexcept; + Function* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_function_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + + +class ThriftHiveMetastore_get_all_functions_args { + public: + + ThriftHiveMetastore_get_all_functions_args(const ThriftHiveMetastore_get_all_functions_args&) noexcept; + ThriftHiveMetastore_get_all_functions_args& operator=(const ThriftHiveMetastore_get_all_functions_args&) noexcept; + ThriftHiveMetastore_get_all_functions_args() noexcept; + + virtual ~ThriftHiveMetastore_get_all_functions_args() noexcept; + + bool operator == (const ThriftHiveMetastore_get_all_functions_args & /* rhs */) const; + bool operator != (const ThriftHiveMetastore_get_all_functions_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_all_functions_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_all_functions_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_all_functions_pargs() noexcept; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_all_functions_result__isset { + _ThriftHiveMetastore_get_all_functions_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_all_functions_result__isset; + +class ThriftHiveMetastore_get_all_functions_result { + public: + + ThriftHiveMetastore_get_all_functions_result(const ThriftHiveMetastore_get_all_functions_result&); + ThriftHiveMetastore_get_all_functions_result& operator=(const ThriftHiveMetastore_get_all_functions_result&); + ThriftHiveMetastore_get_all_functions_result() noexcept; + + virtual ~ThriftHiveMetastore_get_all_functions_result() noexcept; + GetAllFunctionsResponse success; + MetaException o1; + + _ThriftHiveMetastore_get_all_functions_result__isset __isset; + + void __set_success(const GetAllFunctionsResponse& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_all_functions_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_all_functions_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_all_functions_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_all_functions_presult__isset { + _ThriftHiveMetastore_get_all_functions_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_all_functions_presult__isset; + +class ThriftHiveMetastore_get_all_functions_presult { + public: + + + virtual ~ThriftHiveMetastore_get_all_functions_presult() noexcept; + GetAllFunctionsResponse* success; + MetaException o1; + + _ThriftHiveMetastore_get_all_functions_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_create_role_args__isset { + _ThriftHiveMetastore_create_role_args__isset() : role(false) {} + bool role :1; +} _ThriftHiveMetastore_create_role_args__isset; + +class ThriftHiveMetastore_create_role_args { + public: + + ThriftHiveMetastore_create_role_args(const ThriftHiveMetastore_create_role_args&); + ThriftHiveMetastore_create_role_args& operator=(const ThriftHiveMetastore_create_role_args&); + ThriftHiveMetastore_create_role_args() noexcept; + + virtual ~ThriftHiveMetastore_create_role_args() noexcept; + Role role; + + _ThriftHiveMetastore_create_role_args__isset __isset; + + void __set_role(const Role& val); + + bool operator == (const ThriftHiveMetastore_create_role_args & rhs) const; + bool operator != (const ThriftHiveMetastore_create_role_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_role_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_create_role_pargs { + public: + + + virtual ~ThriftHiveMetastore_create_role_pargs() noexcept; + const Role* role; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_role_result__isset { + _ThriftHiveMetastore_create_role_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_create_role_result__isset; + +class ThriftHiveMetastore_create_role_result { + public: + + ThriftHiveMetastore_create_role_result(const ThriftHiveMetastore_create_role_result&); + ThriftHiveMetastore_create_role_result& operator=(const ThriftHiveMetastore_create_role_result&); + ThriftHiveMetastore_create_role_result() noexcept; + + virtual ~ThriftHiveMetastore_create_role_result() noexcept; + bool success; + MetaException o1; + + _ThriftHiveMetastore_create_role_result__isset __isset; + + void __set_success(const bool val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_create_role_result & rhs) const; + bool operator != (const ThriftHiveMetastore_create_role_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_role_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_role_presult__isset { + _ThriftHiveMetastore_create_role_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_create_role_presult__isset; + +class ThriftHiveMetastore_create_role_presult { + public: + + + virtual ~ThriftHiveMetastore_create_role_presult() noexcept; + bool* success; + MetaException o1; + + _ThriftHiveMetastore_create_role_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_role_args__isset { + _ThriftHiveMetastore_drop_role_args__isset() : role_name(false) {} + bool role_name :1; +} _ThriftHiveMetastore_drop_role_args__isset; + +class ThriftHiveMetastore_drop_role_args { + public: + + ThriftHiveMetastore_drop_role_args(const ThriftHiveMetastore_drop_role_args&); + ThriftHiveMetastore_drop_role_args& operator=(const ThriftHiveMetastore_drop_role_args&); + ThriftHiveMetastore_drop_role_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_role_args() noexcept; + std::string role_name; + + _ThriftHiveMetastore_drop_role_args__isset __isset; + + void __set_role_name(const std::string& val); + + bool operator == (const ThriftHiveMetastore_drop_role_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_role_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_role_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_role_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_role_pargs() noexcept; + const std::string* role_name; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_role_result__isset { + _ThriftHiveMetastore_drop_role_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_drop_role_result__isset; + +class ThriftHiveMetastore_drop_role_result { + public: + + ThriftHiveMetastore_drop_role_result(const ThriftHiveMetastore_drop_role_result&); + ThriftHiveMetastore_drop_role_result& operator=(const ThriftHiveMetastore_drop_role_result&); + ThriftHiveMetastore_drop_role_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_role_result() noexcept; + bool success; + MetaException o1; + + _ThriftHiveMetastore_drop_role_result__isset __isset; + + void __set_success(const bool val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_role_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_role_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_role_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_role_presult__isset { + _ThriftHiveMetastore_drop_role_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_drop_role_presult__isset; + +class ThriftHiveMetastore_drop_role_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_role_presult() noexcept; + bool* success; + MetaException o1; + + _ThriftHiveMetastore_drop_role_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + + +class ThriftHiveMetastore_get_role_names_args { + public: + + ThriftHiveMetastore_get_role_names_args(const ThriftHiveMetastore_get_role_names_args&) noexcept; + ThriftHiveMetastore_get_role_names_args& operator=(const ThriftHiveMetastore_get_role_names_args&) noexcept; + ThriftHiveMetastore_get_role_names_args() noexcept; + + virtual ~ThriftHiveMetastore_get_role_names_args() noexcept; + + bool operator == (const ThriftHiveMetastore_get_role_names_args & /* rhs */) const; + bool operator != (const ThriftHiveMetastore_get_role_names_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_role_names_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_role_names_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_role_names_pargs() noexcept; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_role_names_result__isset { + _ThriftHiveMetastore_get_role_names_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_role_names_result__isset; + +class ThriftHiveMetastore_get_role_names_result { + public: + + ThriftHiveMetastore_get_role_names_result(const ThriftHiveMetastore_get_role_names_result&); + ThriftHiveMetastore_get_role_names_result& operator=(const ThriftHiveMetastore_get_role_names_result&); + ThriftHiveMetastore_get_role_names_result() noexcept; + + virtual ~ThriftHiveMetastore_get_role_names_result() noexcept; + std::vector success; + MetaException o1; + + _ThriftHiveMetastore_get_role_names_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_role_names_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_role_names_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_role_names_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_role_names_presult__isset { + _ThriftHiveMetastore_get_role_names_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_role_names_presult__isset; + +class ThriftHiveMetastore_get_role_names_presult { + public: + + + virtual ~ThriftHiveMetastore_get_role_names_presult() noexcept; + std::vector * success; + MetaException o1; + + _ThriftHiveMetastore_get_role_names_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_grant_role_args__isset { + _ThriftHiveMetastore_grant_role_args__isset() : role_name(false), principal_name(false), principal_type(false), grantor(false), grantorType(false), grant_option(false) {} + bool role_name :1; + bool principal_name :1; + bool principal_type :1; + bool grantor :1; + bool grantorType :1; + bool grant_option :1; +} _ThriftHiveMetastore_grant_role_args__isset; + +class ThriftHiveMetastore_grant_role_args { + public: + + ThriftHiveMetastore_grant_role_args(const ThriftHiveMetastore_grant_role_args&); + ThriftHiveMetastore_grant_role_args& operator=(const ThriftHiveMetastore_grant_role_args&); + ThriftHiveMetastore_grant_role_args() noexcept; + + virtual ~ThriftHiveMetastore_grant_role_args() noexcept; + std::string role_name; + std::string principal_name; + /** + * + * @see PrincipalType + */ + PrincipalType::type principal_type; + std::string grantor; + /** + * + * @see PrincipalType + */ + PrincipalType::type grantorType; + bool grant_option; + + _ThriftHiveMetastore_grant_role_args__isset __isset; + + void __set_role_name(const std::string& val); + + void __set_principal_name(const std::string& val); + + void __set_principal_type(const PrincipalType::type val); + + void __set_grantor(const std::string& val); + + void __set_grantorType(const PrincipalType::type val); + + void __set_grant_option(const bool val); + + bool operator == (const ThriftHiveMetastore_grant_role_args & rhs) const; + bool operator != (const ThriftHiveMetastore_grant_role_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_grant_role_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_grant_role_pargs { + public: + + + virtual ~ThriftHiveMetastore_grant_role_pargs() noexcept; + const std::string* role_name; + const std::string* principal_name; + /** + * + * @see PrincipalType + */ + const PrincipalType::type* principal_type; + const std::string* grantor; + /** + * + * @see PrincipalType + */ + const PrincipalType::type* grantorType; + const bool* grant_option; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_grant_role_result__isset { + _ThriftHiveMetastore_grant_role_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_grant_role_result__isset; + +class ThriftHiveMetastore_grant_role_result { + public: + + ThriftHiveMetastore_grant_role_result(const ThriftHiveMetastore_grant_role_result&); + ThriftHiveMetastore_grant_role_result& operator=(const ThriftHiveMetastore_grant_role_result&); + ThriftHiveMetastore_grant_role_result() noexcept; + + virtual ~ThriftHiveMetastore_grant_role_result() noexcept; + bool success; + MetaException o1; + + _ThriftHiveMetastore_grant_role_result__isset __isset; + + void __set_success(const bool val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_grant_role_result & rhs) const; + bool operator != (const ThriftHiveMetastore_grant_role_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_grant_role_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_grant_role_presult__isset { + _ThriftHiveMetastore_grant_role_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_grant_role_presult__isset; + +class ThriftHiveMetastore_grant_role_presult { + public: + + + virtual ~ThriftHiveMetastore_grant_role_presult() noexcept; + bool* success; + MetaException o1; + + _ThriftHiveMetastore_grant_role_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_revoke_role_args__isset { + _ThriftHiveMetastore_revoke_role_args__isset() : role_name(false), principal_name(false), principal_type(false) {} + bool role_name :1; + bool principal_name :1; + bool principal_type :1; +} _ThriftHiveMetastore_revoke_role_args__isset; + +class ThriftHiveMetastore_revoke_role_args { + public: + + ThriftHiveMetastore_revoke_role_args(const ThriftHiveMetastore_revoke_role_args&); + ThriftHiveMetastore_revoke_role_args& operator=(const ThriftHiveMetastore_revoke_role_args&); + ThriftHiveMetastore_revoke_role_args() noexcept; + + virtual ~ThriftHiveMetastore_revoke_role_args() noexcept; + std::string role_name; + std::string principal_name; + /** + * + * @see PrincipalType + */ + PrincipalType::type principal_type; + + _ThriftHiveMetastore_revoke_role_args__isset __isset; + + void __set_role_name(const std::string& val); + + void __set_principal_name(const std::string& val); + + void __set_principal_type(const PrincipalType::type val); + + bool operator == (const ThriftHiveMetastore_revoke_role_args & rhs) const; + bool operator != (const ThriftHiveMetastore_revoke_role_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_revoke_role_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_revoke_role_pargs { + public: + + + virtual ~ThriftHiveMetastore_revoke_role_pargs() noexcept; + const std::string* role_name; + const std::string* principal_name; + /** + * + * @see PrincipalType + */ + const PrincipalType::type* principal_type; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_revoke_role_result__isset { + _ThriftHiveMetastore_revoke_role_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_revoke_role_result__isset; + +class ThriftHiveMetastore_revoke_role_result { + public: + + ThriftHiveMetastore_revoke_role_result(const ThriftHiveMetastore_revoke_role_result&); + ThriftHiveMetastore_revoke_role_result& operator=(const ThriftHiveMetastore_revoke_role_result&); + ThriftHiveMetastore_revoke_role_result() noexcept; + + virtual ~ThriftHiveMetastore_revoke_role_result() noexcept; + bool success; + MetaException o1; + + _ThriftHiveMetastore_revoke_role_result__isset __isset; + + void __set_success(const bool val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_revoke_role_result & rhs) const; + bool operator != (const ThriftHiveMetastore_revoke_role_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_revoke_role_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_revoke_role_presult__isset { + _ThriftHiveMetastore_revoke_role_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_revoke_role_presult__isset; + +class ThriftHiveMetastore_revoke_role_presult { + public: + + + virtual ~ThriftHiveMetastore_revoke_role_presult() noexcept; + bool* success; + MetaException o1; + + _ThriftHiveMetastore_revoke_role_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_list_roles_args__isset { + _ThriftHiveMetastore_list_roles_args__isset() : principal_name(false), principal_type(false) {} + bool principal_name :1; + bool principal_type :1; +} _ThriftHiveMetastore_list_roles_args__isset; + +class ThriftHiveMetastore_list_roles_args { + public: + + ThriftHiveMetastore_list_roles_args(const ThriftHiveMetastore_list_roles_args&); + ThriftHiveMetastore_list_roles_args& operator=(const ThriftHiveMetastore_list_roles_args&); + ThriftHiveMetastore_list_roles_args() noexcept; + + virtual ~ThriftHiveMetastore_list_roles_args() noexcept; + std::string principal_name; + /** + * + * @see PrincipalType + */ + PrincipalType::type principal_type; + + _ThriftHiveMetastore_list_roles_args__isset __isset; + + void __set_principal_name(const std::string& val); + + void __set_principal_type(const PrincipalType::type val); + + bool operator == (const ThriftHiveMetastore_list_roles_args & rhs) const; + bool operator != (const ThriftHiveMetastore_list_roles_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_list_roles_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_list_roles_pargs { + public: + + + virtual ~ThriftHiveMetastore_list_roles_pargs() noexcept; + const std::string* principal_name; + /** + * + * @see PrincipalType + */ + const PrincipalType::type* principal_type; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_list_roles_result__isset { + _ThriftHiveMetastore_list_roles_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_list_roles_result__isset; + +class ThriftHiveMetastore_list_roles_result { + public: + + ThriftHiveMetastore_list_roles_result(const ThriftHiveMetastore_list_roles_result&); + ThriftHiveMetastore_list_roles_result& operator=(const ThriftHiveMetastore_list_roles_result&); + ThriftHiveMetastore_list_roles_result() noexcept; + + virtual ~ThriftHiveMetastore_list_roles_result() noexcept; + std::vector success; + MetaException o1; + + _ThriftHiveMetastore_list_roles_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_list_roles_result & rhs) const; + bool operator != (const ThriftHiveMetastore_list_roles_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_list_roles_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_list_roles_presult__isset { + _ThriftHiveMetastore_list_roles_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_list_roles_presult__isset; + +class ThriftHiveMetastore_list_roles_presult { + public: + + + virtual ~ThriftHiveMetastore_list_roles_presult() noexcept; + std::vector * success; + MetaException o1; + + _ThriftHiveMetastore_list_roles_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_grant_revoke_role_args__isset { + _ThriftHiveMetastore_grant_revoke_role_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_grant_revoke_role_args__isset; + +class ThriftHiveMetastore_grant_revoke_role_args { + public: + + ThriftHiveMetastore_grant_revoke_role_args(const ThriftHiveMetastore_grant_revoke_role_args&); + ThriftHiveMetastore_grant_revoke_role_args& operator=(const ThriftHiveMetastore_grant_revoke_role_args&); + ThriftHiveMetastore_grant_revoke_role_args() noexcept; + + virtual ~ThriftHiveMetastore_grant_revoke_role_args() noexcept; + GrantRevokeRoleRequest request; + + _ThriftHiveMetastore_grant_revoke_role_args__isset __isset; + + void __set_request(const GrantRevokeRoleRequest& val); + + bool operator == (const ThriftHiveMetastore_grant_revoke_role_args & rhs) const; + bool operator != (const ThriftHiveMetastore_grant_revoke_role_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_grant_revoke_role_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_grant_revoke_role_pargs { + public: + + + virtual ~ThriftHiveMetastore_grant_revoke_role_pargs() noexcept; + const GrantRevokeRoleRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_grant_revoke_role_result__isset { + _ThriftHiveMetastore_grant_revoke_role_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_grant_revoke_role_result__isset; + +class ThriftHiveMetastore_grant_revoke_role_result { + public: + + ThriftHiveMetastore_grant_revoke_role_result(const ThriftHiveMetastore_grant_revoke_role_result&); + ThriftHiveMetastore_grant_revoke_role_result& operator=(const ThriftHiveMetastore_grant_revoke_role_result&); + ThriftHiveMetastore_grant_revoke_role_result() noexcept; + + virtual ~ThriftHiveMetastore_grant_revoke_role_result() noexcept; + GrantRevokeRoleResponse success; + MetaException o1; + + _ThriftHiveMetastore_grant_revoke_role_result__isset __isset; + + void __set_success(const GrantRevokeRoleResponse& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_grant_revoke_role_result & rhs) const; + bool operator != (const ThriftHiveMetastore_grant_revoke_role_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_grant_revoke_role_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_grant_revoke_role_presult__isset { + _ThriftHiveMetastore_grant_revoke_role_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_grant_revoke_role_presult__isset; + +class ThriftHiveMetastore_grant_revoke_role_presult { + public: + + + virtual ~ThriftHiveMetastore_grant_revoke_role_presult() noexcept; + GrantRevokeRoleResponse* success; + MetaException o1; + + _ThriftHiveMetastore_grant_revoke_role_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_principals_in_role_args__isset { + _ThriftHiveMetastore_get_principals_in_role_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_principals_in_role_args__isset; + +class ThriftHiveMetastore_get_principals_in_role_args { + public: + + ThriftHiveMetastore_get_principals_in_role_args(const ThriftHiveMetastore_get_principals_in_role_args&); + ThriftHiveMetastore_get_principals_in_role_args& operator=(const ThriftHiveMetastore_get_principals_in_role_args&); + ThriftHiveMetastore_get_principals_in_role_args() noexcept; + + virtual ~ThriftHiveMetastore_get_principals_in_role_args() noexcept; + GetPrincipalsInRoleRequest request; + + _ThriftHiveMetastore_get_principals_in_role_args__isset __isset; + + void __set_request(const GetPrincipalsInRoleRequest& val); + + bool operator == (const ThriftHiveMetastore_get_principals_in_role_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_principals_in_role_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_principals_in_role_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_principals_in_role_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_principals_in_role_pargs() noexcept; + const GetPrincipalsInRoleRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_principals_in_role_result__isset { + _ThriftHiveMetastore_get_principals_in_role_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_principals_in_role_result__isset; + +class ThriftHiveMetastore_get_principals_in_role_result { + public: + + ThriftHiveMetastore_get_principals_in_role_result(const ThriftHiveMetastore_get_principals_in_role_result&); + ThriftHiveMetastore_get_principals_in_role_result& operator=(const ThriftHiveMetastore_get_principals_in_role_result&); + ThriftHiveMetastore_get_principals_in_role_result() noexcept; + + virtual ~ThriftHiveMetastore_get_principals_in_role_result() noexcept; + GetPrincipalsInRoleResponse success; + MetaException o1; + + _ThriftHiveMetastore_get_principals_in_role_result__isset __isset; + + void __set_success(const GetPrincipalsInRoleResponse& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_principals_in_role_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_principals_in_role_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_principals_in_role_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_principals_in_role_presult__isset { + _ThriftHiveMetastore_get_principals_in_role_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_principals_in_role_presult__isset; + +class ThriftHiveMetastore_get_principals_in_role_presult { + public: + + + virtual ~ThriftHiveMetastore_get_principals_in_role_presult() noexcept; + GetPrincipalsInRoleResponse* success; + MetaException o1; + + _ThriftHiveMetastore_get_principals_in_role_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_role_grants_for_principal_args__isset { + _ThriftHiveMetastore_get_role_grants_for_principal_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_role_grants_for_principal_args__isset; + +class ThriftHiveMetastore_get_role_grants_for_principal_args { + public: + + ThriftHiveMetastore_get_role_grants_for_principal_args(const ThriftHiveMetastore_get_role_grants_for_principal_args&); + ThriftHiveMetastore_get_role_grants_for_principal_args& operator=(const ThriftHiveMetastore_get_role_grants_for_principal_args&); + ThriftHiveMetastore_get_role_grants_for_principal_args() noexcept; + + virtual ~ThriftHiveMetastore_get_role_grants_for_principal_args() noexcept; + GetRoleGrantsForPrincipalRequest request; + + _ThriftHiveMetastore_get_role_grants_for_principal_args__isset __isset; + + void __set_request(const GetRoleGrantsForPrincipalRequest& val); + + bool operator == (const ThriftHiveMetastore_get_role_grants_for_principal_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_role_grants_for_principal_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_role_grants_for_principal_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_role_grants_for_principal_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_role_grants_for_principal_pargs() noexcept; + const GetRoleGrantsForPrincipalRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_role_grants_for_principal_result__isset { + _ThriftHiveMetastore_get_role_grants_for_principal_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_role_grants_for_principal_result__isset; + +class ThriftHiveMetastore_get_role_grants_for_principal_result { + public: + + ThriftHiveMetastore_get_role_grants_for_principal_result(const ThriftHiveMetastore_get_role_grants_for_principal_result&); + ThriftHiveMetastore_get_role_grants_for_principal_result& operator=(const ThriftHiveMetastore_get_role_grants_for_principal_result&); + ThriftHiveMetastore_get_role_grants_for_principal_result() noexcept; + + virtual ~ThriftHiveMetastore_get_role_grants_for_principal_result() noexcept; + GetRoleGrantsForPrincipalResponse success; + MetaException o1; + + _ThriftHiveMetastore_get_role_grants_for_principal_result__isset __isset; + + void __set_success(const GetRoleGrantsForPrincipalResponse& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_role_grants_for_principal_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_role_grants_for_principal_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_role_grants_for_principal_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_role_grants_for_principal_presult__isset { + _ThriftHiveMetastore_get_role_grants_for_principal_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_role_grants_for_principal_presult__isset; + +class ThriftHiveMetastore_get_role_grants_for_principal_presult { + public: + + + virtual ~ThriftHiveMetastore_get_role_grants_for_principal_presult() noexcept; + GetRoleGrantsForPrincipalResponse* success; + MetaException o1; + + _ThriftHiveMetastore_get_role_grants_for_principal_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_privilege_set_args__isset { + _ThriftHiveMetastore_get_privilege_set_args__isset() : hiveObject(false), user_name(false), group_names(false) {} + bool hiveObject :1; + bool user_name :1; + bool group_names :1; +} _ThriftHiveMetastore_get_privilege_set_args__isset; + +class ThriftHiveMetastore_get_privilege_set_args { + public: + + ThriftHiveMetastore_get_privilege_set_args(const ThriftHiveMetastore_get_privilege_set_args&); + ThriftHiveMetastore_get_privilege_set_args& operator=(const ThriftHiveMetastore_get_privilege_set_args&); + ThriftHiveMetastore_get_privilege_set_args() noexcept; + + virtual ~ThriftHiveMetastore_get_privilege_set_args() noexcept; + HiveObjectRef hiveObject; + std::string user_name; + std::vector group_names; + + _ThriftHiveMetastore_get_privilege_set_args__isset __isset; + + void __set_hiveObject(const HiveObjectRef& val); + + void __set_user_name(const std::string& val); + + void __set_group_names(const std::vector & val); + + bool operator == (const ThriftHiveMetastore_get_privilege_set_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_privilege_set_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_privilege_set_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_privilege_set_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_privilege_set_pargs() noexcept; + const HiveObjectRef* hiveObject; + const std::string* user_name; + const std::vector * group_names; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_privilege_set_result__isset { + _ThriftHiveMetastore_get_privilege_set_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_privilege_set_result__isset; + +class ThriftHiveMetastore_get_privilege_set_result { + public: + + ThriftHiveMetastore_get_privilege_set_result(const ThriftHiveMetastore_get_privilege_set_result&); + ThriftHiveMetastore_get_privilege_set_result& operator=(const ThriftHiveMetastore_get_privilege_set_result&); + ThriftHiveMetastore_get_privilege_set_result() noexcept; + + virtual ~ThriftHiveMetastore_get_privilege_set_result() noexcept; + PrincipalPrivilegeSet success; + MetaException o1; + + _ThriftHiveMetastore_get_privilege_set_result__isset __isset; + + void __set_success(const PrincipalPrivilegeSet& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_privilege_set_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_privilege_set_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_privilege_set_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_privilege_set_presult__isset { + _ThriftHiveMetastore_get_privilege_set_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_privilege_set_presult__isset; + +class ThriftHiveMetastore_get_privilege_set_presult { + public: + + + virtual ~ThriftHiveMetastore_get_privilege_set_presult() noexcept; + PrincipalPrivilegeSet* success; + MetaException o1; + + _ThriftHiveMetastore_get_privilege_set_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_list_privileges_args__isset { + _ThriftHiveMetastore_list_privileges_args__isset() : principal_name(false), principal_type(false), hiveObject(false) {} + bool principal_name :1; + bool principal_type :1; + bool hiveObject :1; +} _ThriftHiveMetastore_list_privileges_args__isset; + +class ThriftHiveMetastore_list_privileges_args { + public: + + ThriftHiveMetastore_list_privileges_args(const ThriftHiveMetastore_list_privileges_args&); + ThriftHiveMetastore_list_privileges_args& operator=(const ThriftHiveMetastore_list_privileges_args&); + ThriftHiveMetastore_list_privileges_args() noexcept; + + virtual ~ThriftHiveMetastore_list_privileges_args() noexcept; + std::string principal_name; + /** + * + * @see PrincipalType + */ + PrincipalType::type principal_type; + HiveObjectRef hiveObject; + + _ThriftHiveMetastore_list_privileges_args__isset __isset; + + void __set_principal_name(const std::string& val); + + void __set_principal_type(const PrincipalType::type val); + + void __set_hiveObject(const HiveObjectRef& val); + + bool operator == (const ThriftHiveMetastore_list_privileges_args & rhs) const; + bool operator != (const ThriftHiveMetastore_list_privileges_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_list_privileges_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_list_privileges_pargs { + public: + + + virtual ~ThriftHiveMetastore_list_privileges_pargs() noexcept; + const std::string* principal_name; + /** + * + * @see PrincipalType + */ + const PrincipalType::type* principal_type; + const HiveObjectRef* hiveObject; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_list_privileges_result__isset { + _ThriftHiveMetastore_list_privileges_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_list_privileges_result__isset; + +class ThriftHiveMetastore_list_privileges_result { + public: + + ThriftHiveMetastore_list_privileges_result(const ThriftHiveMetastore_list_privileges_result&); + ThriftHiveMetastore_list_privileges_result& operator=(const ThriftHiveMetastore_list_privileges_result&); + ThriftHiveMetastore_list_privileges_result() noexcept; + + virtual ~ThriftHiveMetastore_list_privileges_result() noexcept; + std::vector success; + MetaException o1; + + _ThriftHiveMetastore_list_privileges_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_list_privileges_result & rhs) const; + bool operator != (const ThriftHiveMetastore_list_privileges_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_list_privileges_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_list_privileges_presult__isset { + _ThriftHiveMetastore_list_privileges_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_list_privileges_presult__isset; + +class ThriftHiveMetastore_list_privileges_presult { + public: + + + virtual ~ThriftHiveMetastore_list_privileges_presult() noexcept; + std::vector * success; + MetaException o1; + + _ThriftHiveMetastore_list_privileges_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_grant_privileges_args__isset { + _ThriftHiveMetastore_grant_privileges_args__isset() : privileges(false) {} + bool privileges :1; +} _ThriftHiveMetastore_grant_privileges_args__isset; + +class ThriftHiveMetastore_grant_privileges_args { + public: + + ThriftHiveMetastore_grant_privileges_args(const ThriftHiveMetastore_grant_privileges_args&); + ThriftHiveMetastore_grant_privileges_args& operator=(const ThriftHiveMetastore_grant_privileges_args&); + ThriftHiveMetastore_grant_privileges_args() noexcept; + + virtual ~ThriftHiveMetastore_grant_privileges_args() noexcept; + PrivilegeBag privileges; + + _ThriftHiveMetastore_grant_privileges_args__isset __isset; + + void __set_privileges(const PrivilegeBag& val); + + bool operator == (const ThriftHiveMetastore_grant_privileges_args & rhs) const; + bool operator != (const ThriftHiveMetastore_grant_privileges_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_grant_privileges_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_grant_privileges_pargs { + public: + + + virtual ~ThriftHiveMetastore_grant_privileges_pargs() noexcept; + const PrivilegeBag* privileges; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_grant_privileges_result__isset { + _ThriftHiveMetastore_grant_privileges_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_grant_privileges_result__isset; + +class ThriftHiveMetastore_grant_privileges_result { + public: + + ThriftHiveMetastore_grant_privileges_result(const ThriftHiveMetastore_grant_privileges_result&); + ThriftHiveMetastore_grant_privileges_result& operator=(const ThriftHiveMetastore_grant_privileges_result&); + ThriftHiveMetastore_grant_privileges_result() noexcept; + + virtual ~ThriftHiveMetastore_grant_privileges_result() noexcept; + bool success; + MetaException o1; + + _ThriftHiveMetastore_grant_privileges_result__isset __isset; + + void __set_success(const bool val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_grant_privileges_result & rhs) const; + bool operator != (const ThriftHiveMetastore_grant_privileges_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_grant_privileges_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_grant_privileges_presult__isset { + _ThriftHiveMetastore_grant_privileges_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_grant_privileges_presult__isset; + +class ThriftHiveMetastore_grant_privileges_presult { + public: + + + virtual ~ThriftHiveMetastore_grant_privileges_presult() noexcept; + bool* success; + MetaException o1; + + _ThriftHiveMetastore_grant_privileges_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_revoke_privileges_args__isset { + _ThriftHiveMetastore_revoke_privileges_args__isset() : privileges(false) {} + bool privileges :1; +} _ThriftHiveMetastore_revoke_privileges_args__isset; + +class ThriftHiveMetastore_revoke_privileges_args { + public: + + ThriftHiveMetastore_revoke_privileges_args(const ThriftHiveMetastore_revoke_privileges_args&); + ThriftHiveMetastore_revoke_privileges_args& operator=(const ThriftHiveMetastore_revoke_privileges_args&); + ThriftHiveMetastore_revoke_privileges_args() noexcept; + + virtual ~ThriftHiveMetastore_revoke_privileges_args() noexcept; + PrivilegeBag privileges; + + _ThriftHiveMetastore_revoke_privileges_args__isset __isset; + + void __set_privileges(const PrivilegeBag& val); + + bool operator == (const ThriftHiveMetastore_revoke_privileges_args & rhs) const; + bool operator != (const ThriftHiveMetastore_revoke_privileges_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_revoke_privileges_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_revoke_privileges_pargs { + public: + + + virtual ~ThriftHiveMetastore_revoke_privileges_pargs() noexcept; + const PrivilegeBag* privileges; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_revoke_privileges_result__isset { + _ThriftHiveMetastore_revoke_privileges_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_revoke_privileges_result__isset; + +class ThriftHiveMetastore_revoke_privileges_result { + public: + + ThriftHiveMetastore_revoke_privileges_result(const ThriftHiveMetastore_revoke_privileges_result&); + ThriftHiveMetastore_revoke_privileges_result& operator=(const ThriftHiveMetastore_revoke_privileges_result&); + ThriftHiveMetastore_revoke_privileges_result() noexcept; + + virtual ~ThriftHiveMetastore_revoke_privileges_result() noexcept; + bool success; + MetaException o1; + + _ThriftHiveMetastore_revoke_privileges_result__isset __isset; + + void __set_success(const bool val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_revoke_privileges_result & rhs) const; + bool operator != (const ThriftHiveMetastore_revoke_privileges_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_revoke_privileges_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_revoke_privileges_presult__isset { + _ThriftHiveMetastore_revoke_privileges_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_revoke_privileges_presult__isset; + +class ThriftHiveMetastore_revoke_privileges_presult { + public: + + + virtual ~ThriftHiveMetastore_revoke_privileges_presult() noexcept; + bool* success; + MetaException o1; + + _ThriftHiveMetastore_revoke_privileges_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_grant_revoke_privileges_args__isset { + _ThriftHiveMetastore_grant_revoke_privileges_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_grant_revoke_privileges_args__isset; + +class ThriftHiveMetastore_grant_revoke_privileges_args { + public: + + ThriftHiveMetastore_grant_revoke_privileges_args(const ThriftHiveMetastore_grant_revoke_privileges_args&); + ThriftHiveMetastore_grant_revoke_privileges_args& operator=(const ThriftHiveMetastore_grant_revoke_privileges_args&); + ThriftHiveMetastore_grant_revoke_privileges_args() noexcept; + + virtual ~ThriftHiveMetastore_grant_revoke_privileges_args() noexcept; + GrantRevokePrivilegeRequest request; + + _ThriftHiveMetastore_grant_revoke_privileges_args__isset __isset; + + void __set_request(const GrantRevokePrivilegeRequest& val); + + bool operator == (const ThriftHiveMetastore_grant_revoke_privileges_args & rhs) const; + bool operator != (const ThriftHiveMetastore_grant_revoke_privileges_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_grant_revoke_privileges_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_grant_revoke_privileges_pargs { + public: + + + virtual ~ThriftHiveMetastore_grant_revoke_privileges_pargs() noexcept; + const GrantRevokePrivilegeRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_grant_revoke_privileges_result__isset { + _ThriftHiveMetastore_grant_revoke_privileges_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_grant_revoke_privileges_result__isset; + +class ThriftHiveMetastore_grant_revoke_privileges_result { + public: + + ThriftHiveMetastore_grant_revoke_privileges_result(const ThriftHiveMetastore_grant_revoke_privileges_result&); + ThriftHiveMetastore_grant_revoke_privileges_result& operator=(const ThriftHiveMetastore_grant_revoke_privileges_result&); + ThriftHiveMetastore_grant_revoke_privileges_result() noexcept; + + virtual ~ThriftHiveMetastore_grant_revoke_privileges_result() noexcept; + GrantRevokePrivilegeResponse success; + MetaException o1; + + _ThriftHiveMetastore_grant_revoke_privileges_result__isset __isset; + + void __set_success(const GrantRevokePrivilegeResponse& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_grant_revoke_privileges_result & rhs) const; + bool operator != (const ThriftHiveMetastore_grant_revoke_privileges_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_grant_revoke_privileges_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_grant_revoke_privileges_presult__isset { + _ThriftHiveMetastore_grant_revoke_privileges_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_grant_revoke_privileges_presult__isset; + +class ThriftHiveMetastore_grant_revoke_privileges_presult { + public: + + + virtual ~ThriftHiveMetastore_grant_revoke_privileges_presult() noexcept; + GrantRevokePrivilegeResponse* success; + MetaException o1; + + _ThriftHiveMetastore_grant_revoke_privileges_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_refresh_privileges_args__isset { + _ThriftHiveMetastore_refresh_privileges_args__isset() : objToRefresh(false), authorizer(false), grantRequest(false) {} + bool objToRefresh :1; + bool authorizer :1; + bool grantRequest :1; +} _ThriftHiveMetastore_refresh_privileges_args__isset; + +class ThriftHiveMetastore_refresh_privileges_args { + public: + + ThriftHiveMetastore_refresh_privileges_args(const ThriftHiveMetastore_refresh_privileges_args&); + ThriftHiveMetastore_refresh_privileges_args& operator=(const ThriftHiveMetastore_refresh_privileges_args&); + ThriftHiveMetastore_refresh_privileges_args() noexcept; + + virtual ~ThriftHiveMetastore_refresh_privileges_args() noexcept; + HiveObjectRef objToRefresh; + std::string authorizer; + GrantRevokePrivilegeRequest grantRequest; + + _ThriftHiveMetastore_refresh_privileges_args__isset __isset; + + void __set_objToRefresh(const HiveObjectRef& val); + + void __set_authorizer(const std::string& val); + + void __set_grantRequest(const GrantRevokePrivilegeRequest& val); + + bool operator == (const ThriftHiveMetastore_refresh_privileges_args & rhs) const; + bool operator != (const ThriftHiveMetastore_refresh_privileges_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_refresh_privileges_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_refresh_privileges_pargs { + public: + + + virtual ~ThriftHiveMetastore_refresh_privileges_pargs() noexcept; + const HiveObjectRef* objToRefresh; + const std::string* authorizer; + const GrantRevokePrivilegeRequest* grantRequest; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_refresh_privileges_result__isset { + _ThriftHiveMetastore_refresh_privileges_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_refresh_privileges_result__isset; + +class ThriftHiveMetastore_refresh_privileges_result { + public: + + ThriftHiveMetastore_refresh_privileges_result(const ThriftHiveMetastore_refresh_privileges_result&); + ThriftHiveMetastore_refresh_privileges_result& operator=(const ThriftHiveMetastore_refresh_privileges_result&); + ThriftHiveMetastore_refresh_privileges_result() noexcept; + + virtual ~ThriftHiveMetastore_refresh_privileges_result() noexcept; + GrantRevokePrivilegeResponse success; + MetaException o1; + + _ThriftHiveMetastore_refresh_privileges_result__isset __isset; + + void __set_success(const GrantRevokePrivilegeResponse& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_refresh_privileges_result & rhs) const; + bool operator != (const ThriftHiveMetastore_refresh_privileges_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_refresh_privileges_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_refresh_privileges_presult__isset { + _ThriftHiveMetastore_refresh_privileges_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_refresh_privileges_presult__isset; + +class ThriftHiveMetastore_refresh_privileges_presult { + public: + + + virtual ~ThriftHiveMetastore_refresh_privileges_presult() noexcept; + GrantRevokePrivilegeResponse* success; + MetaException o1; + + _ThriftHiveMetastore_refresh_privileges_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_set_ugi_args__isset { + _ThriftHiveMetastore_set_ugi_args__isset() : user_name(false), group_names(false) {} + bool user_name :1; + bool group_names :1; +} _ThriftHiveMetastore_set_ugi_args__isset; + +class ThriftHiveMetastore_set_ugi_args { + public: + + ThriftHiveMetastore_set_ugi_args(const ThriftHiveMetastore_set_ugi_args&); + ThriftHiveMetastore_set_ugi_args& operator=(const ThriftHiveMetastore_set_ugi_args&); + ThriftHiveMetastore_set_ugi_args() noexcept; + + virtual ~ThriftHiveMetastore_set_ugi_args() noexcept; + std::string user_name; + std::vector group_names; + + _ThriftHiveMetastore_set_ugi_args__isset __isset; + + void __set_user_name(const std::string& val); + + void __set_group_names(const std::vector & val); + + bool operator == (const ThriftHiveMetastore_set_ugi_args & rhs) const; + bool operator != (const ThriftHiveMetastore_set_ugi_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_set_ugi_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_set_ugi_pargs { + public: + + + virtual ~ThriftHiveMetastore_set_ugi_pargs() noexcept; + const std::string* user_name; + const std::vector * group_names; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_set_ugi_result__isset { + _ThriftHiveMetastore_set_ugi_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_set_ugi_result__isset; + +class ThriftHiveMetastore_set_ugi_result { + public: + + ThriftHiveMetastore_set_ugi_result(const ThriftHiveMetastore_set_ugi_result&); + ThriftHiveMetastore_set_ugi_result& operator=(const ThriftHiveMetastore_set_ugi_result&); + ThriftHiveMetastore_set_ugi_result() noexcept; + + virtual ~ThriftHiveMetastore_set_ugi_result() noexcept; + std::vector success; + MetaException o1; + + _ThriftHiveMetastore_set_ugi_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_set_ugi_result & rhs) const; + bool operator != (const ThriftHiveMetastore_set_ugi_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_set_ugi_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_set_ugi_presult__isset { + _ThriftHiveMetastore_set_ugi_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_set_ugi_presult__isset; + +class ThriftHiveMetastore_set_ugi_presult { + public: + + + virtual ~ThriftHiveMetastore_set_ugi_presult() noexcept; + std::vector * success; + MetaException o1; + + _ThriftHiveMetastore_set_ugi_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_delegation_token_args__isset { + _ThriftHiveMetastore_get_delegation_token_args__isset() : token_owner(false), renewer_kerberos_principal_name(false) {} + bool token_owner :1; + bool renewer_kerberos_principal_name :1; +} _ThriftHiveMetastore_get_delegation_token_args__isset; + +class ThriftHiveMetastore_get_delegation_token_args { + public: + + ThriftHiveMetastore_get_delegation_token_args(const ThriftHiveMetastore_get_delegation_token_args&); + ThriftHiveMetastore_get_delegation_token_args& operator=(const ThriftHiveMetastore_get_delegation_token_args&); + ThriftHiveMetastore_get_delegation_token_args() noexcept; + + virtual ~ThriftHiveMetastore_get_delegation_token_args() noexcept; + std::string token_owner; + std::string renewer_kerberos_principal_name; + + _ThriftHiveMetastore_get_delegation_token_args__isset __isset; + + void __set_token_owner(const std::string& val); + + void __set_renewer_kerberos_principal_name(const std::string& val); + + bool operator == (const ThriftHiveMetastore_get_delegation_token_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_delegation_token_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_delegation_token_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_delegation_token_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_delegation_token_pargs() noexcept; + const std::string* token_owner; + const std::string* renewer_kerberos_principal_name; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_delegation_token_result__isset { + _ThriftHiveMetastore_get_delegation_token_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_delegation_token_result__isset; + +class ThriftHiveMetastore_get_delegation_token_result { + public: + + ThriftHiveMetastore_get_delegation_token_result(const ThriftHiveMetastore_get_delegation_token_result&); + ThriftHiveMetastore_get_delegation_token_result& operator=(const ThriftHiveMetastore_get_delegation_token_result&); + ThriftHiveMetastore_get_delegation_token_result() noexcept; + + virtual ~ThriftHiveMetastore_get_delegation_token_result() noexcept; + std::string success; + MetaException o1; + + _ThriftHiveMetastore_get_delegation_token_result__isset __isset; + + void __set_success(const std::string& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_delegation_token_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_delegation_token_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_delegation_token_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_delegation_token_presult__isset { + _ThriftHiveMetastore_get_delegation_token_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_delegation_token_presult__isset; + +class ThriftHiveMetastore_get_delegation_token_presult { + public: + + + virtual ~ThriftHiveMetastore_get_delegation_token_presult() noexcept; + std::string* success; + MetaException o1; + + _ThriftHiveMetastore_get_delegation_token_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_renew_delegation_token_args__isset { + _ThriftHiveMetastore_renew_delegation_token_args__isset() : token_str_form(false) {} + bool token_str_form :1; +} _ThriftHiveMetastore_renew_delegation_token_args__isset; + +class ThriftHiveMetastore_renew_delegation_token_args { + public: + + ThriftHiveMetastore_renew_delegation_token_args(const ThriftHiveMetastore_renew_delegation_token_args&); + ThriftHiveMetastore_renew_delegation_token_args& operator=(const ThriftHiveMetastore_renew_delegation_token_args&); + ThriftHiveMetastore_renew_delegation_token_args() noexcept; + + virtual ~ThriftHiveMetastore_renew_delegation_token_args() noexcept; + std::string token_str_form; + + _ThriftHiveMetastore_renew_delegation_token_args__isset __isset; + + void __set_token_str_form(const std::string& val); + + bool operator == (const ThriftHiveMetastore_renew_delegation_token_args & rhs) const; + bool operator != (const ThriftHiveMetastore_renew_delegation_token_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_renew_delegation_token_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_renew_delegation_token_pargs { + public: + + + virtual ~ThriftHiveMetastore_renew_delegation_token_pargs() noexcept; + const std::string* token_str_form; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_renew_delegation_token_result__isset { + _ThriftHiveMetastore_renew_delegation_token_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_renew_delegation_token_result__isset; + +class ThriftHiveMetastore_renew_delegation_token_result { + public: + + ThriftHiveMetastore_renew_delegation_token_result(const ThriftHiveMetastore_renew_delegation_token_result&); + ThriftHiveMetastore_renew_delegation_token_result& operator=(const ThriftHiveMetastore_renew_delegation_token_result&); + ThriftHiveMetastore_renew_delegation_token_result() noexcept; + + virtual ~ThriftHiveMetastore_renew_delegation_token_result() noexcept; + int64_t success; + MetaException o1; + + _ThriftHiveMetastore_renew_delegation_token_result__isset __isset; + + void __set_success(const int64_t val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_renew_delegation_token_result & rhs) const; + bool operator != (const ThriftHiveMetastore_renew_delegation_token_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_renew_delegation_token_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_renew_delegation_token_presult__isset { + _ThriftHiveMetastore_renew_delegation_token_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_renew_delegation_token_presult__isset; + +class ThriftHiveMetastore_renew_delegation_token_presult { + public: + + + virtual ~ThriftHiveMetastore_renew_delegation_token_presult() noexcept; + int64_t* success; + MetaException o1; + + _ThriftHiveMetastore_renew_delegation_token_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_cancel_delegation_token_args__isset { + _ThriftHiveMetastore_cancel_delegation_token_args__isset() : token_str_form(false) {} + bool token_str_form :1; +} _ThriftHiveMetastore_cancel_delegation_token_args__isset; + +class ThriftHiveMetastore_cancel_delegation_token_args { + public: + + ThriftHiveMetastore_cancel_delegation_token_args(const ThriftHiveMetastore_cancel_delegation_token_args&); + ThriftHiveMetastore_cancel_delegation_token_args& operator=(const ThriftHiveMetastore_cancel_delegation_token_args&); + ThriftHiveMetastore_cancel_delegation_token_args() noexcept; + + virtual ~ThriftHiveMetastore_cancel_delegation_token_args() noexcept; + std::string token_str_form; + + _ThriftHiveMetastore_cancel_delegation_token_args__isset __isset; + + void __set_token_str_form(const std::string& val); + + bool operator == (const ThriftHiveMetastore_cancel_delegation_token_args & rhs) const; + bool operator != (const ThriftHiveMetastore_cancel_delegation_token_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_cancel_delegation_token_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_cancel_delegation_token_pargs { + public: + + + virtual ~ThriftHiveMetastore_cancel_delegation_token_pargs() noexcept; + const std::string* token_str_form; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_cancel_delegation_token_result__isset { + _ThriftHiveMetastore_cancel_delegation_token_result__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_cancel_delegation_token_result__isset; + +class ThriftHiveMetastore_cancel_delegation_token_result { + public: + + ThriftHiveMetastore_cancel_delegation_token_result(const ThriftHiveMetastore_cancel_delegation_token_result&); + ThriftHiveMetastore_cancel_delegation_token_result& operator=(const ThriftHiveMetastore_cancel_delegation_token_result&); + ThriftHiveMetastore_cancel_delegation_token_result() noexcept; + + virtual ~ThriftHiveMetastore_cancel_delegation_token_result() noexcept; + MetaException o1; + + _ThriftHiveMetastore_cancel_delegation_token_result__isset __isset; + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_cancel_delegation_token_result & rhs) const; + bool operator != (const ThriftHiveMetastore_cancel_delegation_token_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_cancel_delegation_token_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_cancel_delegation_token_presult__isset { + _ThriftHiveMetastore_cancel_delegation_token_presult__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_cancel_delegation_token_presult__isset; + +class ThriftHiveMetastore_cancel_delegation_token_presult { + public: + + + virtual ~ThriftHiveMetastore_cancel_delegation_token_presult() noexcept; + MetaException o1; + + _ThriftHiveMetastore_cancel_delegation_token_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_add_token_args__isset { + _ThriftHiveMetastore_add_token_args__isset() : token_identifier(false), delegation_token(false) {} + bool token_identifier :1; + bool delegation_token :1; +} _ThriftHiveMetastore_add_token_args__isset; + +class ThriftHiveMetastore_add_token_args { + public: + + ThriftHiveMetastore_add_token_args(const ThriftHiveMetastore_add_token_args&); + ThriftHiveMetastore_add_token_args& operator=(const ThriftHiveMetastore_add_token_args&); + ThriftHiveMetastore_add_token_args() noexcept; + + virtual ~ThriftHiveMetastore_add_token_args() noexcept; + std::string token_identifier; + std::string delegation_token; + + _ThriftHiveMetastore_add_token_args__isset __isset; + + void __set_token_identifier(const std::string& val); + + void __set_delegation_token(const std::string& val); + + bool operator == (const ThriftHiveMetastore_add_token_args & rhs) const; + bool operator != (const ThriftHiveMetastore_add_token_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_token_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_token_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_token_pargs() noexcept; + const std::string* token_identifier; + const std::string* delegation_token; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_token_result__isset { + _ThriftHiveMetastore_add_token_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_add_token_result__isset; + +class ThriftHiveMetastore_add_token_result { + public: + + ThriftHiveMetastore_add_token_result(const ThriftHiveMetastore_add_token_result&) noexcept; + ThriftHiveMetastore_add_token_result& operator=(const ThriftHiveMetastore_add_token_result&) noexcept; + ThriftHiveMetastore_add_token_result() noexcept; + + virtual ~ThriftHiveMetastore_add_token_result() noexcept; + bool success; + + _ThriftHiveMetastore_add_token_result__isset __isset; + + void __set_success(const bool val); + + bool operator == (const ThriftHiveMetastore_add_token_result & rhs) const; + bool operator != (const ThriftHiveMetastore_add_token_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_token_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_token_presult__isset { + _ThriftHiveMetastore_add_token_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_add_token_presult__isset; + +class ThriftHiveMetastore_add_token_presult { + public: + + + virtual ~ThriftHiveMetastore_add_token_presult() noexcept; + bool* success; + + _ThriftHiveMetastore_add_token_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_remove_token_args__isset { + _ThriftHiveMetastore_remove_token_args__isset() : token_identifier(false) {} + bool token_identifier :1; +} _ThriftHiveMetastore_remove_token_args__isset; + +class ThriftHiveMetastore_remove_token_args { + public: + + ThriftHiveMetastore_remove_token_args(const ThriftHiveMetastore_remove_token_args&); + ThriftHiveMetastore_remove_token_args& operator=(const ThriftHiveMetastore_remove_token_args&); + ThriftHiveMetastore_remove_token_args() noexcept; + + virtual ~ThriftHiveMetastore_remove_token_args() noexcept; + std::string token_identifier; + + _ThriftHiveMetastore_remove_token_args__isset __isset; + + void __set_token_identifier(const std::string& val); + + bool operator == (const ThriftHiveMetastore_remove_token_args & rhs) const; + bool operator != (const ThriftHiveMetastore_remove_token_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_remove_token_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_remove_token_pargs { + public: + + + virtual ~ThriftHiveMetastore_remove_token_pargs() noexcept; + const std::string* token_identifier; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_remove_token_result__isset { + _ThriftHiveMetastore_remove_token_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_remove_token_result__isset; + +class ThriftHiveMetastore_remove_token_result { + public: + + ThriftHiveMetastore_remove_token_result(const ThriftHiveMetastore_remove_token_result&) noexcept; + ThriftHiveMetastore_remove_token_result& operator=(const ThriftHiveMetastore_remove_token_result&) noexcept; + ThriftHiveMetastore_remove_token_result() noexcept; + + virtual ~ThriftHiveMetastore_remove_token_result() noexcept; + bool success; + + _ThriftHiveMetastore_remove_token_result__isset __isset; + + void __set_success(const bool val); + + bool operator == (const ThriftHiveMetastore_remove_token_result & rhs) const; + bool operator != (const ThriftHiveMetastore_remove_token_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_remove_token_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_remove_token_presult__isset { + _ThriftHiveMetastore_remove_token_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_remove_token_presult__isset; + +class ThriftHiveMetastore_remove_token_presult { + public: + + + virtual ~ThriftHiveMetastore_remove_token_presult() noexcept; + bool* success; + + _ThriftHiveMetastore_remove_token_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_token_args__isset { + _ThriftHiveMetastore_get_token_args__isset() : token_identifier(false) {} + bool token_identifier :1; +} _ThriftHiveMetastore_get_token_args__isset; + +class ThriftHiveMetastore_get_token_args { + public: + + ThriftHiveMetastore_get_token_args(const ThriftHiveMetastore_get_token_args&); + ThriftHiveMetastore_get_token_args& operator=(const ThriftHiveMetastore_get_token_args&); + ThriftHiveMetastore_get_token_args() noexcept; + + virtual ~ThriftHiveMetastore_get_token_args() noexcept; + std::string token_identifier; + + _ThriftHiveMetastore_get_token_args__isset __isset; + + void __set_token_identifier(const std::string& val); + + bool operator == (const ThriftHiveMetastore_get_token_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_token_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_token_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_token_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_token_pargs() noexcept; + const std::string* token_identifier; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_token_result__isset { + _ThriftHiveMetastore_get_token_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_token_result__isset; + +class ThriftHiveMetastore_get_token_result { + public: + + ThriftHiveMetastore_get_token_result(const ThriftHiveMetastore_get_token_result&); + ThriftHiveMetastore_get_token_result& operator=(const ThriftHiveMetastore_get_token_result&); + ThriftHiveMetastore_get_token_result() noexcept; + + virtual ~ThriftHiveMetastore_get_token_result() noexcept; + std::string success; + + _ThriftHiveMetastore_get_token_result__isset __isset; + + void __set_success(const std::string& val); + + bool operator == (const ThriftHiveMetastore_get_token_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_token_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_token_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_token_presult__isset { + _ThriftHiveMetastore_get_token_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_token_presult__isset; + +class ThriftHiveMetastore_get_token_presult { + public: + + + virtual ~ThriftHiveMetastore_get_token_presult() noexcept; + std::string* success; + + _ThriftHiveMetastore_get_token_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + + +class ThriftHiveMetastore_get_all_token_identifiers_args { + public: + + ThriftHiveMetastore_get_all_token_identifiers_args(const ThriftHiveMetastore_get_all_token_identifiers_args&) noexcept; + ThriftHiveMetastore_get_all_token_identifiers_args& operator=(const ThriftHiveMetastore_get_all_token_identifiers_args&) noexcept; + ThriftHiveMetastore_get_all_token_identifiers_args() noexcept; + + virtual ~ThriftHiveMetastore_get_all_token_identifiers_args() noexcept; + + bool operator == (const ThriftHiveMetastore_get_all_token_identifiers_args & /* rhs */) const; + bool operator != (const ThriftHiveMetastore_get_all_token_identifiers_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_all_token_identifiers_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_all_token_identifiers_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_all_token_identifiers_pargs() noexcept; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_all_token_identifiers_result__isset { + _ThriftHiveMetastore_get_all_token_identifiers_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_all_token_identifiers_result__isset; + +class ThriftHiveMetastore_get_all_token_identifiers_result { + public: + + ThriftHiveMetastore_get_all_token_identifiers_result(const ThriftHiveMetastore_get_all_token_identifiers_result&); + ThriftHiveMetastore_get_all_token_identifiers_result& operator=(const ThriftHiveMetastore_get_all_token_identifiers_result&); + ThriftHiveMetastore_get_all_token_identifiers_result() noexcept; + + virtual ~ThriftHiveMetastore_get_all_token_identifiers_result() noexcept; + std::vector success; + + _ThriftHiveMetastore_get_all_token_identifiers_result__isset __isset; + + void __set_success(const std::vector & val); + + bool operator == (const ThriftHiveMetastore_get_all_token_identifiers_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_all_token_identifiers_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_all_token_identifiers_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_all_token_identifiers_presult__isset { + _ThriftHiveMetastore_get_all_token_identifiers_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_all_token_identifiers_presult__isset; + +class ThriftHiveMetastore_get_all_token_identifiers_presult { + public: + + + virtual ~ThriftHiveMetastore_get_all_token_identifiers_presult() noexcept; + std::vector * success; + + _ThriftHiveMetastore_get_all_token_identifiers_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_add_master_key_args__isset { + _ThriftHiveMetastore_add_master_key_args__isset() : key(false) {} + bool key :1; +} _ThriftHiveMetastore_add_master_key_args__isset; + +class ThriftHiveMetastore_add_master_key_args { + public: + + ThriftHiveMetastore_add_master_key_args(const ThriftHiveMetastore_add_master_key_args&); + ThriftHiveMetastore_add_master_key_args& operator=(const ThriftHiveMetastore_add_master_key_args&); + ThriftHiveMetastore_add_master_key_args() noexcept; + + virtual ~ThriftHiveMetastore_add_master_key_args() noexcept; + std::string key; + + _ThriftHiveMetastore_add_master_key_args__isset __isset; + + void __set_key(const std::string& val); + + bool operator == (const ThriftHiveMetastore_add_master_key_args & rhs) const; + bool operator != (const ThriftHiveMetastore_add_master_key_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_master_key_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_master_key_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_master_key_pargs() noexcept; + const std::string* key; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_master_key_result__isset { + _ThriftHiveMetastore_add_master_key_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_add_master_key_result__isset; + +class ThriftHiveMetastore_add_master_key_result { + public: + + ThriftHiveMetastore_add_master_key_result(const ThriftHiveMetastore_add_master_key_result&); + ThriftHiveMetastore_add_master_key_result& operator=(const ThriftHiveMetastore_add_master_key_result&); + ThriftHiveMetastore_add_master_key_result() noexcept; + + virtual ~ThriftHiveMetastore_add_master_key_result() noexcept; + int32_t success; + MetaException o1; + + _ThriftHiveMetastore_add_master_key_result__isset __isset; + + void __set_success(const int32_t val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_add_master_key_result & rhs) const; + bool operator != (const ThriftHiveMetastore_add_master_key_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_master_key_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_master_key_presult__isset { + _ThriftHiveMetastore_add_master_key_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_add_master_key_presult__isset; + +class ThriftHiveMetastore_add_master_key_presult { + public: + + + virtual ~ThriftHiveMetastore_add_master_key_presult() noexcept; + int32_t* success; + MetaException o1; + + _ThriftHiveMetastore_add_master_key_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_update_master_key_args__isset { + _ThriftHiveMetastore_update_master_key_args__isset() : seq_number(false), key(false) {} + bool seq_number :1; + bool key :1; +} _ThriftHiveMetastore_update_master_key_args__isset; + +class ThriftHiveMetastore_update_master_key_args { + public: + + ThriftHiveMetastore_update_master_key_args(const ThriftHiveMetastore_update_master_key_args&); + ThriftHiveMetastore_update_master_key_args& operator=(const ThriftHiveMetastore_update_master_key_args&); + ThriftHiveMetastore_update_master_key_args() noexcept; + + virtual ~ThriftHiveMetastore_update_master_key_args() noexcept; + int32_t seq_number; + std::string key; + + _ThriftHiveMetastore_update_master_key_args__isset __isset; + + void __set_seq_number(const int32_t val); + + void __set_key(const std::string& val); + + bool operator == (const ThriftHiveMetastore_update_master_key_args & rhs) const; + bool operator != (const ThriftHiveMetastore_update_master_key_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_update_master_key_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_update_master_key_pargs { + public: + + + virtual ~ThriftHiveMetastore_update_master_key_pargs() noexcept; + const int32_t* seq_number; + const std::string* key; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_update_master_key_result__isset { + _ThriftHiveMetastore_update_master_key_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_update_master_key_result__isset; + +class ThriftHiveMetastore_update_master_key_result { + public: + + ThriftHiveMetastore_update_master_key_result(const ThriftHiveMetastore_update_master_key_result&); + ThriftHiveMetastore_update_master_key_result& operator=(const ThriftHiveMetastore_update_master_key_result&); + ThriftHiveMetastore_update_master_key_result() noexcept; + + virtual ~ThriftHiveMetastore_update_master_key_result() noexcept; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_update_master_key_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_update_master_key_result & rhs) const; + bool operator != (const ThriftHiveMetastore_update_master_key_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_update_master_key_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_update_master_key_presult__isset { + _ThriftHiveMetastore_update_master_key_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_update_master_key_presult__isset; + +class ThriftHiveMetastore_update_master_key_presult { + public: + + + virtual ~ThriftHiveMetastore_update_master_key_presult() noexcept; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_update_master_key_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_remove_master_key_args__isset { + _ThriftHiveMetastore_remove_master_key_args__isset() : key_seq(false) {} + bool key_seq :1; +} _ThriftHiveMetastore_remove_master_key_args__isset; + +class ThriftHiveMetastore_remove_master_key_args { + public: + + ThriftHiveMetastore_remove_master_key_args(const ThriftHiveMetastore_remove_master_key_args&) noexcept; + ThriftHiveMetastore_remove_master_key_args& operator=(const ThriftHiveMetastore_remove_master_key_args&) noexcept; + ThriftHiveMetastore_remove_master_key_args() noexcept; + + virtual ~ThriftHiveMetastore_remove_master_key_args() noexcept; + int32_t key_seq; + + _ThriftHiveMetastore_remove_master_key_args__isset __isset; + + void __set_key_seq(const int32_t val); + + bool operator == (const ThriftHiveMetastore_remove_master_key_args & rhs) const; + bool operator != (const ThriftHiveMetastore_remove_master_key_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_remove_master_key_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_remove_master_key_pargs { + public: + + + virtual ~ThriftHiveMetastore_remove_master_key_pargs() noexcept; + const int32_t* key_seq; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_remove_master_key_result__isset { + _ThriftHiveMetastore_remove_master_key_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_remove_master_key_result__isset; + +class ThriftHiveMetastore_remove_master_key_result { + public: + + ThriftHiveMetastore_remove_master_key_result(const ThriftHiveMetastore_remove_master_key_result&) noexcept; + ThriftHiveMetastore_remove_master_key_result& operator=(const ThriftHiveMetastore_remove_master_key_result&) noexcept; + ThriftHiveMetastore_remove_master_key_result() noexcept; + + virtual ~ThriftHiveMetastore_remove_master_key_result() noexcept; + bool success; + + _ThriftHiveMetastore_remove_master_key_result__isset __isset; + + void __set_success(const bool val); + + bool operator == (const ThriftHiveMetastore_remove_master_key_result & rhs) const; + bool operator != (const ThriftHiveMetastore_remove_master_key_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_remove_master_key_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_remove_master_key_presult__isset { + _ThriftHiveMetastore_remove_master_key_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_remove_master_key_presult__isset; + +class ThriftHiveMetastore_remove_master_key_presult { + public: + + + virtual ~ThriftHiveMetastore_remove_master_key_presult() noexcept; + bool* success; + + _ThriftHiveMetastore_remove_master_key_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + + +class ThriftHiveMetastore_get_master_keys_args { + public: + + ThriftHiveMetastore_get_master_keys_args(const ThriftHiveMetastore_get_master_keys_args&) noexcept; + ThriftHiveMetastore_get_master_keys_args& operator=(const ThriftHiveMetastore_get_master_keys_args&) noexcept; + ThriftHiveMetastore_get_master_keys_args() noexcept; + + virtual ~ThriftHiveMetastore_get_master_keys_args() noexcept; + + bool operator == (const ThriftHiveMetastore_get_master_keys_args & /* rhs */) const; + bool operator != (const ThriftHiveMetastore_get_master_keys_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_master_keys_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_master_keys_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_master_keys_pargs() noexcept; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_master_keys_result__isset { + _ThriftHiveMetastore_get_master_keys_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_master_keys_result__isset; + +class ThriftHiveMetastore_get_master_keys_result { + public: + + ThriftHiveMetastore_get_master_keys_result(const ThriftHiveMetastore_get_master_keys_result&); + ThriftHiveMetastore_get_master_keys_result& operator=(const ThriftHiveMetastore_get_master_keys_result&); + ThriftHiveMetastore_get_master_keys_result() noexcept; + + virtual ~ThriftHiveMetastore_get_master_keys_result() noexcept; + std::vector success; + + _ThriftHiveMetastore_get_master_keys_result__isset __isset; + + void __set_success(const std::vector & val); + + bool operator == (const ThriftHiveMetastore_get_master_keys_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_master_keys_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_master_keys_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_master_keys_presult__isset { + _ThriftHiveMetastore_get_master_keys_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_master_keys_presult__isset; + +class ThriftHiveMetastore_get_master_keys_presult { + public: + + + virtual ~ThriftHiveMetastore_get_master_keys_presult() noexcept; + std::vector * success; + + _ThriftHiveMetastore_get_master_keys_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + + +class ThriftHiveMetastore_get_open_txns_args { + public: + + ThriftHiveMetastore_get_open_txns_args(const ThriftHiveMetastore_get_open_txns_args&) noexcept; + ThriftHiveMetastore_get_open_txns_args& operator=(const ThriftHiveMetastore_get_open_txns_args&) noexcept; + ThriftHiveMetastore_get_open_txns_args() noexcept; + + virtual ~ThriftHiveMetastore_get_open_txns_args() noexcept; + + bool operator == (const ThriftHiveMetastore_get_open_txns_args & /* rhs */) const; + bool operator != (const ThriftHiveMetastore_get_open_txns_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_open_txns_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_open_txns_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_open_txns_pargs() noexcept; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_open_txns_result__isset { + _ThriftHiveMetastore_get_open_txns_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_open_txns_result__isset; + +class ThriftHiveMetastore_get_open_txns_result { + public: + + ThriftHiveMetastore_get_open_txns_result(const ThriftHiveMetastore_get_open_txns_result&); + ThriftHiveMetastore_get_open_txns_result& operator=(const ThriftHiveMetastore_get_open_txns_result&); + ThriftHiveMetastore_get_open_txns_result() noexcept; + + virtual ~ThriftHiveMetastore_get_open_txns_result() noexcept; + GetOpenTxnsResponse success; + + _ThriftHiveMetastore_get_open_txns_result__isset __isset; + + void __set_success(const GetOpenTxnsResponse& val); + + bool operator == (const ThriftHiveMetastore_get_open_txns_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_open_txns_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_open_txns_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_open_txns_presult__isset { + _ThriftHiveMetastore_get_open_txns_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_open_txns_presult__isset; + +class ThriftHiveMetastore_get_open_txns_presult { + public: + + + virtual ~ThriftHiveMetastore_get_open_txns_presult() noexcept; + GetOpenTxnsResponse* success; + + _ThriftHiveMetastore_get_open_txns_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + + +class ThriftHiveMetastore_get_open_txns_info_args { + public: + + ThriftHiveMetastore_get_open_txns_info_args(const ThriftHiveMetastore_get_open_txns_info_args&) noexcept; + ThriftHiveMetastore_get_open_txns_info_args& operator=(const ThriftHiveMetastore_get_open_txns_info_args&) noexcept; + ThriftHiveMetastore_get_open_txns_info_args() noexcept; + + virtual ~ThriftHiveMetastore_get_open_txns_info_args() noexcept; + + bool operator == (const ThriftHiveMetastore_get_open_txns_info_args & /* rhs */) const; + bool operator != (const ThriftHiveMetastore_get_open_txns_info_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_open_txns_info_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_open_txns_info_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_open_txns_info_pargs() noexcept; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_open_txns_info_result__isset { + _ThriftHiveMetastore_get_open_txns_info_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_open_txns_info_result__isset; + +class ThriftHiveMetastore_get_open_txns_info_result { + public: + + ThriftHiveMetastore_get_open_txns_info_result(const ThriftHiveMetastore_get_open_txns_info_result&); + ThriftHiveMetastore_get_open_txns_info_result& operator=(const ThriftHiveMetastore_get_open_txns_info_result&); + ThriftHiveMetastore_get_open_txns_info_result() noexcept; + + virtual ~ThriftHiveMetastore_get_open_txns_info_result() noexcept; + GetOpenTxnsInfoResponse success; + + _ThriftHiveMetastore_get_open_txns_info_result__isset __isset; + + void __set_success(const GetOpenTxnsInfoResponse& val); + + bool operator == (const ThriftHiveMetastore_get_open_txns_info_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_open_txns_info_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_open_txns_info_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_open_txns_info_presult__isset { + _ThriftHiveMetastore_get_open_txns_info_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_open_txns_info_presult__isset; + +class ThriftHiveMetastore_get_open_txns_info_presult { + public: + + + virtual ~ThriftHiveMetastore_get_open_txns_info_presult() noexcept; + GetOpenTxnsInfoResponse* success; + + _ThriftHiveMetastore_get_open_txns_info_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_open_txns_args__isset { + _ThriftHiveMetastore_open_txns_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_open_txns_args__isset; + +class ThriftHiveMetastore_open_txns_args { + public: + + ThriftHiveMetastore_open_txns_args(const ThriftHiveMetastore_open_txns_args&); + ThriftHiveMetastore_open_txns_args& operator=(const ThriftHiveMetastore_open_txns_args&); + ThriftHiveMetastore_open_txns_args() noexcept; + + virtual ~ThriftHiveMetastore_open_txns_args() noexcept; + OpenTxnRequest rqst; + + _ThriftHiveMetastore_open_txns_args__isset __isset; + + void __set_rqst(const OpenTxnRequest& val); + + bool operator == (const ThriftHiveMetastore_open_txns_args & rhs) const; + bool operator != (const ThriftHiveMetastore_open_txns_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_open_txns_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_open_txns_pargs { + public: + + + virtual ~ThriftHiveMetastore_open_txns_pargs() noexcept; + const OpenTxnRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_open_txns_result__isset { + _ThriftHiveMetastore_open_txns_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_open_txns_result__isset; + +class ThriftHiveMetastore_open_txns_result { + public: + + ThriftHiveMetastore_open_txns_result(const ThriftHiveMetastore_open_txns_result&); + ThriftHiveMetastore_open_txns_result& operator=(const ThriftHiveMetastore_open_txns_result&); + ThriftHiveMetastore_open_txns_result() noexcept; + + virtual ~ThriftHiveMetastore_open_txns_result() noexcept; + OpenTxnsResponse success; + + _ThriftHiveMetastore_open_txns_result__isset __isset; + + void __set_success(const OpenTxnsResponse& val); + + bool operator == (const ThriftHiveMetastore_open_txns_result & rhs) const; + bool operator != (const ThriftHiveMetastore_open_txns_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_open_txns_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_open_txns_presult__isset { + _ThriftHiveMetastore_open_txns_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_open_txns_presult__isset; + +class ThriftHiveMetastore_open_txns_presult { + public: + + + virtual ~ThriftHiveMetastore_open_txns_presult() noexcept; + OpenTxnsResponse* success; + + _ThriftHiveMetastore_open_txns_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_abort_txn_args__isset { + _ThriftHiveMetastore_abort_txn_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_abort_txn_args__isset; + +class ThriftHiveMetastore_abort_txn_args { + public: + + ThriftHiveMetastore_abort_txn_args(const ThriftHiveMetastore_abort_txn_args&); + ThriftHiveMetastore_abort_txn_args& operator=(const ThriftHiveMetastore_abort_txn_args&); + ThriftHiveMetastore_abort_txn_args() noexcept; + + virtual ~ThriftHiveMetastore_abort_txn_args() noexcept; + AbortTxnRequest rqst; + + _ThriftHiveMetastore_abort_txn_args__isset __isset; + + void __set_rqst(const AbortTxnRequest& val); + + bool operator == (const ThriftHiveMetastore_abort_txn_args & rhs) const; + bool operator != (const ThriftHiveMetastore_abort_txn_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_abort_txn_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_abort_txn_pargs { + public: + + + virtual ~ThriftHiveMetastore_abort_txn_pargs() noexcept; + const AbortTxnRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_abort_txn_result__isset { + _ThriftHiveMetastore_abort_txn_result__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_abort_txn_result__isset; + +class ThriftHiveMetastore_abort_txn_result { + public: + + ThriftHiveMetastore_abort_txn_result(const ThriftHiveMetastore_abort_txn_result&); + ThriftHiveMetastore_abort_txn_result& operator=(const ThriftHiveMetastore_abort_txn_result&); + ThriftHiveMetastore_abort_txn_result() noexcept; + + virtual ~ThriftHiveMetastore_abort_txn_result() noexcept; + NoSuchTxnException o1; + + _ThriftHiveMetastore_abort_txn_result__isset __isset; + + void __set_o1(const NoSuchTxnException& val); + + bool operator == (const ThriftHiveMetastore_abort_txn_result & rhs) const; + bool operator != (const ThriftHiveMetastore_abort_txn_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_abort_txn_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_abort_txn_presult__isset { + _ThriftHiveMetastore_abort_txn_presult__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_abort_txn_presult__isset; + +class ThriftHiveMetastore_abort_txn_presult { + public: + + + virtual ~ThriftHiveMetastore_abort_txn_presult() noexcept; + NoSuchTxnException o1; + + _ThriftHiveMetastore_abort_txn_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_abort_txns_args__isset { + _ThriftHiveMetastore_abort_txns_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_abort_txns_args__isset; + +class ThriftHiveMetastore_abort_txns_args { + public: + + ThriftHiveMetastore_abort_txns_args(const ThriftHiveMetastore_abort_txns_args&); + ThriftHiveMetastore_abort_txns_args& operator=(const ThriftHiveMetastore_abort_txns_args&); + ThriftHiveMetastore_abort_txns_args() noexcept; + + virtual ~ThriftHiveMetastore_abort_txns_args() noexcept; + AbortTxnsRequest rqst; + + _ThriftHiveMetastore_abort_txns_args__isset __isset; + + void __set_rqst(const AbortTxnsRequest& val); + + bool operator == (const ThriftHiveMetastore_abort_txns_args & rhs) const; + bool operator != (const ThriftHiveMetastore_abort_txns_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_abort_txns_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_abort_txns_pargs { + public: + + + virtual ~ThriftHiveMetastore_abort_txns_pargs() noexcept; + const AbortTxnsRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_abort_txns_result__isset { + _ThriftHiveMetastore_abort_txns_result__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_abort_txns_result__isset; + +class ThriftHiveMetastore_abort_txns_result { + public: + + ThriftHiveMetastore_abort_txns_result(const ThriftHiveMetastore_abort_txns_result&); + ThriftHiveMetastore_abort_txns_result& operator=(const ThriftHiveMetastore_abort_txns_result&); + ThriftHiveMetastore_abort_txns_result() noexcept; + + virtual ~ThriftHiveMetastore_abort_txns_result() noexcept; + NoSuchTxnException o1; + + _ThriftHiveMetastore_abort_txns_result__isset __isset; + + void __set_o1(const NoSuchTxnException& val); + + bool operator == (const ThriftHiveMetastore_abort_txns_result & rhs) const; + bool operator != (const ThriftHiveMetastore_abort_txns_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_abort_txns_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_abort_txns_presult__isset { + _ThriftHiveMetastore_abort_txns_presult__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_abort_txns_presult__isset; + +class ThriftHiveMetastore_abort_txns_presult { + public: + + + virtual ~ThriftHiveMetastore_abort_txns_presult() noexcept; + NoSuchTxnException o1; + + _ThriftHiveMetastore_abort_txns_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_commit_txn_args__isset { + _ThriftHiveMetastore_commit_txn_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_commit_txn_args__isset; + +class ThriftHiveMetastore_commit_txn_args { + public: + + ThriftHiveMetastore_commit_txn_args(const ThriftHiveMetastore_commit_txn_args&); + ThriftHiveMetastore_commit_txn_args& operator=(const ThriftHiveMetastore_commit_txn_args&); + ThriftHiveMetastore_commit_txn_args() noexcept; + + virtual ~ThriftHiveMetastore_commit_txn_args() noexcept; + CommitTxnRequest rqst; + + _ThriftHiveMetastore_commit_txn_args__isset __isset; + + void __set_rqst(const CommitTxnRequest& val); + + bool operator == (const ThriftHiveMetastore_commit_txn_args & rhs) const; + bool operator != (const ThriftHiveMetastore_commit_txn_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_commit_txn_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_commit_txn_pargs { + public: + + + virtual ~ThriftHiveMetastore_commit_txn_pargs() noexcept; + const CommitTxnRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_commit_txn_result__isset { + _ThriftHiveMetastore_commit_txn_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_commit_txn_result__isset; + +class ThriftHiveMetastore_commit_txn_result { + public: + + ThriftHiveMetastore_commit_txn_result(const ThriftHiveMetastore_commit_txn_result&); + ThriftHiveMetastore_commit_txn_result& operator=(const ThriftHiveMetastore_commit_txn_result&); + ThriftHiveMetastore_commit_txn_result() noexcept; + + virtual ~ThriftHiveMetastore_commit_txn_result() noexcept; + NoSuchTxnException o1; + TxnAbortedException o2; + + _ThriftHiveMetastore_commit_txn_result__isset __isset; + + void __set_o1(const NoSuchTxnException& val); + + void __set_o2(const TxnAbortedException& val); + + bool operator == (const ThriftHiveMetastore_commit_txn_result & rhs) const; + bool operator != (const ThriftHiveMetastore_commit_txn_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_commit_txn_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_commit_txn_presult__isset { + _ThriftHiveMetastore_commit_txn_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_commit_txn_presult__isset; + +class ThriftHiveMetastore_commit_txn_presult { + public: + + + virtual ~ThriftHiveMetastore_commit_txn_presult() noexcept; + NoSuchTxnException o1; + TxnAbortedException o2; + + _ThriftHiveMetastore_commit_txn_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_latest_txnid_in_conflict_args__isset { + _ThriftHiveMetastore_get_latest_txnid_in_conflict_args__isset() : txnId(false) {} + bool txnId :1; +} _ThriftHiveMetastore_get_latest_txnid_in_conflict_args__isset; + +class ThriftHiveMetastore_get_latest_txnid_in_conflict_args { + public: + + ThriftHiveMetastore_get_latest_txnid_in_conflict_args(const ThriftHiveMetastore_get_latest_txnid_in_conflict_args&) noexcept; + ThriftHiveMetastore_get_latest_txnid_in_conflict_args& operator=(const ThriftHiveMetastore_get_latest_txnid_in_conflict_args&) noexcept; + ThriftHiveMetastore_get_latest_txnid_in_conflict_args() noexcept; + + virtual ~ThriftHiveMetastore_get_latest_txnid_in_conflict_args() noexcept; + int64_t txnId; + + _ThriftHiveMetastore_get_latest_txnid_in_conflict_args__isset __isset; + + void __set_txnId(const int64_t val); + + bool operator == (const ThriftHiveMetastore_get_latest_txnid_in_conflict_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_latest_txnid_in_conflict_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_latest_txnid_in_conflict_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_latest_txnid_in_conflict_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_latest_txnid_in_conflict_pargs() noexcept; + const int64_t* txnId; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_latest_txnid_in_conflict_result__isset { + _ThriftHiveMetastore_get_latest_txnid_in_conflict_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_latest_txnid_in_conflict_result__isset; + +class ThriftHiveMetastore_get_latest_txnid_in_conflict_result { + public: + + ThriftHiveMetastore_get_latest_txnid_in_conflict_result(const ThriftHiveMetastore_get_latest_txnid_in_conflict_result&); + ThriftHiveMetastore_get_latest_txnid_in_conflict_result& operator=(const ThriftHiveMetastore_get_latest_txnid_in_conflict_result&); + ThriftHiveMetastore_get_latest_txnid_in_conflict_result() noexcept; + + virtual ~ThriftHiveMetastore_get_latest_txnid_in_conflict_result() noexcept; + int64_t success; + MetaException o1; + + _ThriftHiveMetastore_get_latest_txnid_in_conflict_result__isset __isset; + + void __set_success(const int64_t val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_latest_txnid_in_conflict_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_latest_txnid_in_conflict_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_latest_txnid_in_conflict_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_latest_txnid_in_conflict_presult__isset { + _ThriftHiveMetastore_get_latest_txnid_in_conflict_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_latest_txnid_in_conflict_presult__isset; + +class ThriftHiveMetastore_get_latest_txnid_in_conflict_presult { + public: + + + virtual ~ThriftHiveMetastore_get_latest_txnid_in_conflict_presult() noexcept; + int64_t* success; + MetaException o1; + + _ThriftHiveMetastore_get_latest_txnid_in_conflict_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_repl_tbl_writeid_state_args__isset { + _ThriftHiveMetastore_repl_tbl_writeid_state_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_repl_tbl_writeid_state_args__isset; + +class ThriftHiveMetastore_repl_tbl_writeid_state_args { + public: + + ThriftHiveMetastore_repl_tbl_writeid_state_args(const ThriftHiveMetastore_repl_tbl_writeid_state_args&); + ThriftHiveMetastore_repl_tbl_writeid_state_args& operator=(const ThriftHiveMetastore_repl_tbl_writeid_state_args&); + ThriftHiveMetastore_repl_tbl_writeid_state_args() noexcept; + + virtual ~ThriftHiveMetastore_repl_tbl_writeid_state_args() noexcept; + ReplTblWriteIdStateRequest rqst; + + _ThriftHiveMetastore_repl_tbl_writeid_state_args__isset __isset; + + void __set_rqst(const ReplTblWriteIdStateRequest& val); + + bool operator == (const ThriftHiveMetastore_repl_tbl_writeid_state_args & rhs) const; + bool operator != (const ThriftHiveMetastore_repl_tbl_writeid_state_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_repl_tbl_writeid_state_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_repl_tbl_writeid_state_pargs { + public: + + + virtual ~ThriftHiveMetastore_repl_tbl_writeid_state_pargs() noexcept; + const ReplTblWriteIdStateRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_repl_tbl_writeid_state_result { + public: + + ThriftHiveMetastore_repl_tbl_writeid_state_result(const ThriftHiveMetastore_repl_tbl_writeid_state_result&) noexcept; + ThriftHiveMetastore_repl_tbl_writeid_state_result& operator=(const ThriftHiveMetastore_repl_tbl_writeid_state_result&) noexcept; + ThriftHiveMetastore_repl_tbl_writeid_state_result() noexcept; + + virtual ~ThriftHiveMetastore_repl_tbl_writeid_state_result() noexcept; + + bool operator == (const ThriftHiveMetastore_repl_tbl_writeid_state_result & /* rhs */) const; + bool operator != (const ThriftHiveMetastore_repl_tbl_writeid_state_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_repl_tbl_writeid_state_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_repl_tbl_writeid_state_presult { + public: + + + virtual ~ThriftHiveMetastore_repl_tbl_writeid_state_presult() noexcept; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_valid_write_ids_args__isset { + _ThriftHiveMetastore_get_valid_write_ids_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_get_valid_write_ids_args__isset; + +class ThriftHiveMetastore_get_valid_write_ids_args { + public: + + ThriftHiveMetastore_get_valid_write_ids_args(const ThriftHiveMetastore_get_valid_write_ids_args&); + ThriftHiveMetastore_get_valid_write_ids_args& operator=(const ThriftHiveMetastore_get_valid_write_ids_args&); + ThriftHiveMetastore_get_valid_write_ids_args() noexcept; + + virtual ~ThriftHiveMetastore_get_valid_write_ids_args() noexcept; + GetValidWriteIdsRequest rqst; + + _ThriftHiveMetastore_get_valid_write_ids_args__isset __isset; + + void __set_rqst(const GetValidWriteIdsRequest& val); + + bool operator == (const ThriftHiveMetastore_get_valid_write_ids_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_valid_write_ids_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_valid_write_ids_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_valid_write_ids_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_valid_write_ids_pargs() noexcept; + const GetValidWriteIdsRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_valid_write_ids_result__isset { + _ThriftHiveMetastore_get_valid_write_ids_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_valid_write_ids_result__isset; + +class ThriftHiveMetastore_get_valid_write_ids_result { + public: + + ThriftHiveMetastore_get_valid_write_ids_result(const ThriftHiveMetastore_get_valid_write_ids_result&); + ThriftHiveMetastore_get_valid_write_ids_result& operator=(const ThriftHiveMetastore_get_valid_write_ids_result&); + ThriftHiveMetastore_get_valid_write_ids_result() noexcept; + + virtual ~ThriftHiveMetastore_get_valid_write_ids_result() noexcept; + GetValidWriteIdsResponse success; + NoSuchTxnException o1; + MetaException o2; + + _ThriftHiveMetastore_get_valid_write_ids_result__isset __isset; + + void __set_success(const GetValidWriteIdsResponse& val); + + void __set_o1(const NoSuchTxnException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_valid_write_ids_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_valid_write_ids_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_valid_write_ids_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_valid_write_ids_presult__isset { + _ThriftHiveMetastore_get_valid_write_ids_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_valid_write_ids_presult__isset; + +class ThriftHiveMetastore_get_valid_write_ids_presult { + public: + + + virtual ~ThriftHiveMetastore_get_valid_write_ids_presult() noexcept; + GetValidWriteIdsResponse* success; + NoSuchTxnException o1; + MetaException o2; + + _ThriftHiveMetastore_get_valid_write_ids_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_add_write_ids_to_min_history_args__isset { + _ThriftHiveMetastore_add_write_ids_to_min_history_args__isset() : txnId(false), writeIds(false) {} + bool txnId :1; + bool writeIds :1; +} _ThriftHiveMetastore_add_write_ids_to_min_history_args__isset; + +class ThriftHiveMetastore_add_write_ids_to_min_history_args { + public: + + ThriftHiveMetastore_add_write_ids_to_min_history_args(const ThriftHiveMetastore_add_write_ids_to_min_history_args&); + ThriftHiveMetastore_add_write_ids_to_min_history_args& operator=(const ThriftHiveMetastore_add_write_ids_to_min_history_args&); + ThriftHiveMetastore_add_write_ids_to_min_history_args() noexcept; + + virtual ~ThriftHiveMetastore_add_write_ids_to_min_history_args() noexcept; + int64_t txnId; + std::map writeIds; + + _ThriftHiveMetastore_add_write_ids_to_min_history_args__isset __isset; + + void __set_txnId(const int64_t val); + + void __set_writeIds(const std::map & val); + + bool operator == (const ThriftHiveMetastore_add_write_ids_to_min_history_args & rhs) const; + bool operator != (const ThriftHiveMetastore_add_write_ids_to_min_history_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_write_ids_to_min_history_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_write_ids_to_min_history_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_write_ids_to_min_history_pargs() noexcept; + const int64_t* txnId; + const std::map * writeIds; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_write_ids_to_min_history_result__isset { + _ThriftHiveMetastore_add_write_ids_to_min_history_result__isset() : o2(false) {} + bool o2 :1; +} _ThriftHiveMetastore_add_write_ids_to_min_history_result__isset; + +class ThriftHiveMetastore_add_write_ids_to_min_history_result { + public: + + ThriftHiveMetastore_add_write_ids_to_min_history_result(const ThriftHiveMetastore_add_write_ids_to_min_history_result&); + ThriftHiveMetastore_add_write_ids_to_min_history_result& operator=(const ThriftHiveMetastore_add_write_ids_to_min_history_result&); + ThriftHiveMetastore_add_write_ids_to_min_history_result() noexcept; + + virtual ~ThriftHiveMetastore_add_write_ids_to_min_history_result() noexcept; + MetaException o2; + + _ThriftHiveMetastore_add_write_ids_to_min_history_result__isset __isset; + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_add_write_ids_to_min_history_result & rhs) const; + bool operator != (const ThriftHiveMetastore_add_write_ids_to_min_history_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_write_ids_to_min_history_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_write_ids_to_min_history_presult__isset { + _ThriftHiveMetastore_add_write_ids_to_min_history_presult__isset() : o2(false) {} + bool o2 :1; +} _ThriftHiveMetastore_add_write_ids_to_min_history_presult__isset; + +class ThriftHiveMetastore_add_write_ids_to_min_history_presult { + public: + + + virtual ~ThriftHiveMetastore_add_write_ids_to_min_history_presult() noexcept; + MetaException o2; + + _ThriftHiveMetastore_add_write_ids_to_min_history_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_allocate_table_write_ids_args__isset { + _ThriftHiveMetastore_allocate_table_write_ids_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_allocate_table_write_ids_args__isset; + +class ThriftHiveMetastore_allocate_table_write_ids_args { + public: + + ThriftHiveMetastore_allocate_table_write_ids_args(const ThriftHiveMetastore_allocate_table_write_ids_args&); + ThriftHiveMetastore_allocate_table_write_ids_args& operator=(const ThriftHiveMetastore_allocate_table_write_ids_args&); + ThriftHiveMetastore_allocate_table_write_ids_args() noexcept; + + virtual ~ThriftHiveMetastore_allocate_table_write_ids_args() noexcept; + AllocateTableWriteIdsRequest rqst; + + _ThriftHiveMetastore_allocate_table_write_ids_args__isset __isset; + + void __set_rqst(const AllocateTableWriteIdsRequest& val); + + bool operator == (const ThriftHiveMetastore_allocate_table_write_ids_args & rhs) const; + bool operator != (const ThriftHiveMetastore_allocate_table_write_ids_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_allocate_table_write_ids_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_allocate_table_write_ids_pargs { + public: + + + virtual ~ThriftHiveMetastore_allocate_table_write_ids_pargs() noexcept; + const AllocateTableWriteIdsRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_allocate_table_write_ids_result__isset { + _ThriftHiveMetastore_allocate_table_write_ids_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_allocate_table_write_ids_result__isset; + +class ThriftHiveMetastore_allocate_table_write_ids_result { + public: + + ThriftHiveMetastore_allocate_table_write_ids_result(const ThriftHiveMetastore_allocate_table_write_ids_result&); + ThriftHiveMetastore_allocate_table_write_ids_result& operator=(const ThriftHiveMetastore_allocate_table_write_ids_result&); + ThriftHiveMetastore_allocate_table_write_ids_result() noexcept; + + virtual ~ThriftHiveMetastore_allocate_table_write_ids_result() noexcept; + AllocateTableWriteIdsResponse success; + NoSuchTxnException o1; + TxnAbortedException o2; + MetaException o3; + + _ThriftHiveMetastore_allocate_table_write_ids_result__isset __isset; + + void __set_success(const AllocateTableWriteIdsResponse& val); + + void __set_o1(const NoSuchTxnException& val); + + void __set_o2(const TxnAbortedException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_allocate_table_write_ids_result & rhs) const; + bool operator != (const ThriftHiveMetastore_allocate_table_write_ids_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_allocate_table_write_ids_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_allocate_table_write_ids_presult__isset { + _ThriftHiveMetastore_allocate_table_write_ids_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_allocate_table_write_ids_presult__isset; + +class ThriftHiveMetastore_allocate_table_write_ids_presult { + public: + + + virtual ~ThriftHiveMetastore_allocate_table_write_ids_presult() noexcept; + AllocateTableWriteIdsResponse* success; + NoSuchTxnException o1; + TxnAbortedException o2; + MetaException o3; + + _ThriftHiveMetastore_allocate_table_write_ids_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_max_allocated_table_write_id_args__isset { + _ThriftHiveMetastore_get_max_allocated_table_write_id_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_get_max_allocated_table_write_id_args__isset; + +class ThriftHiveMetastore_get_max_allocated_table_write_id_args { + public: + + ThriftHiveMetastore_get_max_allocated_table_write_id_args(const ThriftHiveMetastore_get_max_allocated_table_write_id_args&); + ThriftHiveMetastore_get_max_allocated_table_write_id_args& operator=(const ThriftHiveMetastore_get_max_allocated_table_write_id_args&); + ThriftHiveMetastore_get_max_allocated_table_write_id_args() noexcept; + + virtual ~ThriftHiveMetastore_get_max_allocated_table_write_id_args() noexcept; + MaxAllocatedTableWriteIdRequest rqst; + + _ThriftHiveMetastore_get_max_allocated_table_write_id_args__isset __isset; + + void __set_rqst(const MaxAllocatedTableWriteIdRequest& val); + + bool operator == (const ThriftHiveMetastore_get_max_allocated_table_write_id_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_max_allocated_table_write_id_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_max_allocated_table_write_id_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_max_allocated_table_write_id_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_max_allocated_table_write_id_pargs() noexcept; + const MaxAllocatedTableWriteIdRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_max_allocated_table_write_id_result__isset { + _ThriftHiveMetastore_get_max_allocated_table_write_id_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_max_allocated_table_write_id_result__isset; + +class ThriftHiveMetastore_get_max_allocated_table_write_id_result { + public: + + ThriftHiveMetastore_get_max_allocated_table_write_id_result(const ThriftHiveMetastore_get_max_allocated_table_write_id_result&); + ThriftHiveMetastore_get_max_allocated_table_write_id_result& operator=(const ThriftHiveMetastore_get_max_allocated_table_write_id_result&); + ThriftHiveMetastore_get_max_allocated_table_write_id_result() noexcept; + + virtual ~ThriftHiveMetastore_get_max_allocated_table_write_id_result() noexcept; + MaxAllocatedTableWriteIdResponse success; + MetaException o1; + + _ThriftHiveMetastore_get_max_allocated_table_write_id_result__isset __isset; + + void __set_success(const MaxAllocatedTableWriteIdResponse& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_max_allocated_table_write_id_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_max_allocated_table_write_id_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_max_allocated_table_write_id_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_max_allocated_table_write_id_presult__isset { + _ThriftHiveMetastore_get_max_allocated_table_write_id_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_max_allocated_table_write_id_presult__isset; + +class ThriftHiveMetastore_get_max_allocated_table_write_id_presult { + public: + + + virtual ~ThriftHiveMetastore_get_max_allocated_table_write_id_presult() noexcept; + MaxAllocatedTableWriteIdResponse* success; + MetaException o1; + + _ThriftHiveMetastore_get_max_allocated_table_write_id_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_seed_write_id_args__isset { + _ThriftHiveMetastore_seed_write_id_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_seed_write_id_args__isset; + +class ThriftHiveMetastore_seed_write_id_args { + public: + + ThriftHiveMetastore_seed_write_id_args(const ThriftHiveMetastore_seed_write_id_args&); + ThriftHiveMetastore_seed_write_id_args& operator=(const ThriftHiveMetastore_seed_write_id_args&); + ThriftHiveMetastore_seed_write_id_args() noexcept; + + virtual ~ThriftHiveMetastore_seed_write_id_args() noexcept; + SeedTableWriteIdsRequest rqst; + + _ThriftHiveMetastore_seed_write_id_args__isset __isset; + + void __set_rqst(const SeedTableWriteIdsRequest& val); + + bool operator == (const ThriftHiveMetastore_seed_write_id_args & rhs) const; + bool operator != (const ThriftHiveMetastore_seed_write_id_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_seed_write_id_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_seed_write_id_pargs { + public: + + + virtual ~ThriftHiveMetastore_seed_write_id_pargs() noexcept; + const SeedTableWriteIdsRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_seed_write_id_result__isset { + _ThriftHiveMetastore_seed_write_id_result__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_seed_write_id_result__isset; + +class ThriftHiveMetastore_seed_write_id_result { + public: + + ThriftHiveMetastore_seed_write_id_result(const ThriftHiveMetastore_seed_write_id_result&); + ThriftHiveMetastore_seed_write_id_result& operator=(const ThriftHiveMetastore_seed_write_id_result&); + ThriftHiveMetastore_seed_write_id_result() noexcept; + + virtual ~ThriftHiveMetastore_seed_write_id_result() noexcept; + MetaException o1; + + _ThriftHiveMetastore_seed_write_id_result__isset __isset; + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_seed_write_id_result & rhs) const; + bool operator != (const ThriftHiveMetastore_seed_write_id_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_seed_write_id_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_seed_write_id_presult__isset { + _ThriftHiveMetastore_seed_write_id_presult__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_seed_write_id_presult__isset; + +class ThriftHiveMetastore_seed_write_id_presult { + public: + + + virtual ~ThriftHiveMetastore_seed_write_id_presult() noexcept; + MetaException o1; + + _ThriftHiveMetastore_seed_write_id_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_seed_txn_id_args__isset { + _ThriftHiveMetastore_seed_txn_id_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_seed_txn_id_args__isset; + +class ThriftHiveMetastore_seed_txn_id_args { + public: + + ThriftHiveMetastore_seed_txn_id_args(const ThriftHiveMetastore_seed_txn_id_args&) noexcept; + ThriftHiveMetastore_seed_txn_id_args& operator=(const ThriftHiveMetastore_seed_txn_id_args&) noexcept; + ThriftHiveMetastore_seed_txn_id_args() noexcept; + + virtual ~ThriftHiveMetastore_seed_txn_id_args() noexcept; + SeedTxnIdRequest rqst; + + _ThriftHiveMetastore_seed_txn_id_args__isset __isset; + + void __set_rqst(const SeedTxnIdRequest& val); + + bool operator == (const ThriftHiveMetastore_seed_txn_id_args & rhs) const; + bool operator != (const ThriftHiveMetastore_seed_txn_id_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_seed_txn_id_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_seed_txn_id_pargs { + public: + + + virtual ~ThriftHiveMetastore_seed_txn_id_pargs() noexcept; + const SeedTxnIdRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_seed_txn_id_result__isset { + _ThriftHiveMetastore_seed_txn_id_result__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_seed_txn_id_result__isset; + +class ThriftHiveMetastore_seed_txn_id_result { + public: + + ThriftHiveMetastore_seed_txn_id_result(const ThriftHiveMetastore_seed_txn_id_result&); + ThriftHiveMetastore_seed_txn_id_result& operator=(const ThriftHiveMetastore_seed_txn_id_result&); + ThriftHiveMetastore_seed_txn_id_result() noexcept; + + virtual ~ThriftHiveMetastore_seed_txn_id_result() noexcept; + MetaException o1; + + _ThriftHiveMetastore_seed_txn_id_result__isset __isset; + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_seed_txn_id_result & rhs) const; + bool operator != (const ThriftHiveMetastore_seed_txn_id_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_seed_txn_id_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_seed_txn_id_presult__isset { + _ThriftHiveMetastore_seed_txn_id_presult__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_seed_txn_id_presult__isset; + +class ThriftHiveMetastore_seed_txn_id_presult { + public: + + + virtual ~ThriftHiveMetastore_seed_txn_id_presult() noexcept; + MetaException o1; + + _ThriftHiveMetastore_seed_txn_id_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_lock_args__isset { + _ThriftHiveMetastore_lock_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_lock_args__isset; + +class ThriftHiveMetastore_lock_args { + public: + + ThriftHiveMetastore_lock_args(const ThriftHiveMetastore_lock_args&); + ThriftHiveMetastore_lock_args& operator=(const ThriftHiveMetastore_lock_args&); + ThriftHiveMetastore_lock_args() noexcept; + + virtual ~ThriftHiveMetastore_lock_args() noexcept; + LockRequest rqst; + + _ThriftHiveMetastore_lock_args__isset __isset; + + void __set_rqst(const LockRequest& val); + + bool operator == (const ThriftHiveMetastore_lock_args & rhs) const; + bool operator != (const ThriftHiveMetastore_lock_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_lock_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_lock_pargs { + public: + + + virtual ~ThriftHiveMetastore_lock_pargs() noexcept; + const LockRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_lock_result__isset { + _ThriftHiveMetastore_lock_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_lock_result__isset; + +class ThriftHiveMetastore_lock_result { + public: + + ThriftHiveMetastore_lock_result(const ThriftHiveMetastore_lock_result&); + ThriftHiveMetastore_lock_result& operator=(const ThriftHiveMetastore_lock_result&); + ThriftHiveMetastore_lock_result() noexcept; + + virtual ~ThriftHiveMetastore_lock_result() noexcept; + LockResponse success; + NoSuchTxnException o1; + TxnAbortedException o2; + + _ThriftHiveMetastore_lock_result__isset __isset; + + void __set_success(const LockResponse& val); + + void __set_o1(const NoSuchTxnException& val); + + void __set_o2(const TxnAbortedException& val); + + bool operator == (const ThriftHiveMetastore_lock_result & rhs) const; + bool operator != (const ThriftHiveMetastore_lock_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_lock_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_lock_presult__isset { + _ThriftHiveMetastore_lock_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_lock_presult__isset; + +class ThriftHiveMetastore_lock_presult { + public: + + + virtual ~ThriftHiveMetastore_lock_presult() noexcept; + LockResponse* success; + NoSuchTxnException o1; + TxnAbortedException o2; + + _ThriftHiveMetastore_lock_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_check_lock_args__isset { + _ThriftHiveMetastore_check_lock_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_check_lock_args__isset; + +class ThriftHiveMetastore_check_lock_args { + public: + + ThriftHiveMetastore_check_lock_args(const ThriftHiveMetastore_check_lock_args&) noexcept; + ThriftHiveMetastore_check_lock_args& operator=(const ThriftHiveMetastore_check_lock_args&) noexcept; + ThriftHiveMetastore_check_lock_args() noexcept; + + virtual ~ThriftHiveMetastore_check_lock_args() noexcept; + CheckLockRequest rqst; + + _ThriftHiveMetastore_check_lock_args__isset __isset; + + void __set_rqst(const CheckLockRequest& val); + + bool operator == (const ThriftHiveMetastore_check_lock_args & rhs) const; + bool operator != (const ThriftHiveMetastore_check_lock_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_check_lock_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_check_lock_pargs { + public: + + + virtual ~ThriftHiveMetastore_check_lock_pargs() noexcept; + const CheckLockRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_check_lock_result__isset { + _ThriftHiveMetastore_check_lock_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_check_lock_result__isset; + +class ThriftHiveMetastore_check_lock_result { + public: + + ThriftHiveMetastore_check_lock_result(const ThriftHiveMetastore_check_lock_result&); + ThriftHiveMetastore_check_lock_result& operator=(const ThriftHiveMetastore_check_lock_result&); + ThriftHiveMetastore_check_lock_result() noexcept; + + virtual ~ThriftHiveMetastore_check_lock_result() noexcept; + LockResponse success; + NoSuchTxnException o1; + TxnAbortedException o2; + NoSuchLockException o3; + + _ThriftHiveMetastore_check_lock_result__isset __isset; + + void __set_success(const LockResponse& val); + + void __set_o1(const NoSuchTxnException& val); + + void __set_o2(const TxnAbortedException& val); + + void __set_o3(const NoSuchLockException& val); + + bool operator == (const ThriftHiveMetastore_check_lock_result & rhs) const; + bool operator != (const ThriftHiveMetastore_check_lock_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_check_lock_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_check_lock_presult__isset { + _ThriftHiveMetastore_check_lock_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_check_lock_presult__isset; + +class ThriftHiveMetastore_check_lock_presult { + public: + + + virtual ~ThriftHiveMetastore_check_lock_presult() noexcept; + LockResponse* success; + NoSuchTxnException o1; + TxnAbortedException o2; + NoSuchLockException o3; + + _ThriftHiveMetastore_check_lock_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_unlock_args__isset { + _ThriftHiveMetastore_unlock_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_unlock_args__isset; + +class ThriftHiveMetastore_unlock_args { + public: + + ThriftHiveMetastore_unlock_args(const ThriftHiveMetastore_unlock_args&) noexcept; + ThriftHiveMetastore_unlock_args& operator=(const ThriftHiveMetastore_unlock_args&) noexcept; + ThriftHiveMetastore_unlock_args() noexcept; + + virtual ~ThriftHiveMetastore_unlock_args() noexcept; + UnlockRequest rqst; + + _ThriftHiveMetastore_unlock_args__isset __isset; + + void __set_rqst(const UnlockRequest& val); + + bool operator == (const ThriftHiveMetastore_unlock_args & rhs) const; + bool operator != (const ThriftHiveMetastore_unlock_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_unlock_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_unlock_pargs { + public: + + + virtual ~ThriftHiveMetastore_unlock_pargs() noexcept; + const UnlockRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_unlock_result__isset { + _ThriftHiveMetastore_unlock_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_unlock_result__isset; + +class ThriftHiveMetastore_unlock_result { + public: + + ThriftHiveMetastore_unlock_result(const ThriftHiveMetastore_unlock_result&); + ThriftHiveMetastore_unlock_result& operator=(const ThriftHiveMetastore_unlock_result&); + ThriftHiveMetastore_unlock_result() noexcept; + + virtual ~ThriftHiveMetastore_unlock_result() noexcept; + NoSuchLockException o1; + TxnOpenException o2; + + _ThriftHiveMetastore_unlock_result__isset __isset; + + void __set_o1(const NoSuchLockException& val); + + void __set_o2(const TxnOpenException& val); + + bool operator == (const ThriftHiveMetastore_unlock_result & rhs) const; + bool operator != (const ThriftHiveMetastore_unlock_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_unlock_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_unlock_presult__isset { + _ThriftHiveMetastore_unlock_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_unlock_presult__isset; + +class ThriftHiveMetastore_unlock_presult { + public: + + + virtual ~ThriftHiveMetastore_unlock_presult() noexcept; + NoSuchLockException o1; + TxnOpenException o2; + + _ThriftHiveMetastore_unlock_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_show_locks_args__isset { + _ThriftHiveMetastore_show_locks_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_show_locks_args__isset; + +class ThriftHiveMetastore_show_locks_args { + public: + + ThriftHiveMetastore_show_locks_args(const ThriftHiveMetastore_show_locks_args&); + ThriftHiveMetastore_show_locks_args& operator=(const ThriftHiveMetastore_show_locks_args&); + ThriftHiveMetastore_show_locks_args() noexcept; + + virtual ~ThriftHiveMetastore_show_locks_args() noexcept; + ShowLocksRequest rqst; + + _ThriftHiveMetastore_show_locks_args__isset __isset; + + void __set_rqst(const ShowLocksRequest& val); + + bool operator == (const ThriftHiveMetastore_show_locks_args & rhs) const; + bool operator != (const ThriftHiveMetastore_show_locks_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_show_locks_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_show_locks_pargs { + public: + + + virtual ~ThriftHiveMetastore_show_locks_pargs() noexcept; + const ShowLocksRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_show_locks_result__isset { + _ThriftHiveMetastore_show_locks_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_show_locks_result__isset; + +class ThriftHiveMetastore_show_locks_result { + public: + + ThriftHiveMetastore_show_locks_result(const ThriftHiveMetastore_show_locks_result&); + ThriftHiveMetastore_show_locks_result& operator=(const ThriftHiveMetastore_show_locks_result&); + ThriftHiveMetastore_show_locks_result() noexcept; + + virtual ~ThriftHiveMetastore_show_locks_result() noexcept; + ShowLocksResponse success; + + _ThriftHiveMetastore_show_locks_result__isset __isset; + + void __set_success(const ShowLocksResponse& val); + + bool operator == (const ThriftHiveMetastore_show_locks_result & rhs) const; + bool operator != (const ThriftHiveMetastore_show_locks_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_show_locks_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_show_locks_presult__isset { + _ThriftHiveMetastore_show_locks_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_show_locks_presult__isset; + +class ThriftHiveMetastore_show_locks_presult { + public: + + + virtual ~ThriftHiveMetastore_show_locks_presult() noexcept; + ShowLocksResponse* success; + + _ThriftHiveMetastore_show_locks_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_heartbeat_args__isset { + _ThriftHiveMetastore_heartbeat_args__isset() : ids(false) {} + bool ids :1; +} _ThriftHiveMetastore_heartbeat_args__isset; + +class ThriftHiveMetastore_heartbeat_args { + public: + + ThriftHiveMetastore_heartbeat_args(const ThriftHiveMetastore_heartbeat_args&) noexcept; + ThriftHiveMetastore_heartbeat_args& operator=(const ThriftHiveMetastore_heartbeat_args&) noexcept; + ThriftHiveMetastore_heartbeat_args() noexcept; + + virtual ~ThriftHiveMetastore_heartbeat_args() noexcept; + HeartbeatRequest ids; + + _ThriftHiveMetastore_heartbeat_args__isset __isset; + + void __set_ids(const HeartbeatRequest& val); + + bool operator == (const ThriftHiveMetastore_heartbeat_args & rhs) const; + bool operator != (const ThriftHiveMetastore_heartbeat_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_heartbeat_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_heartbeat_pargs { + public: + + + virtual ~ThriftHiveMetastore_heartbeat_pargs() noexcept; + const HeartbeatRequest* ids; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_heartbeat_result__isset { + _ThriftHiveMetastore_heartbeat_result__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_heartbeat_result__isset; + +class ThriftHiveMetastore_heartbeat_result { + public: + + ThriftHiveMetastore_heartbeat_result(const ThriftHiveMetastore_heartbeat_result&); + ThriftHiveMetastore_heartbeat_result& operator=(const ThriftHiveMetastore_heartbeat_result&); + ThriftHiveMetastore_heartbeat_result() noexcept; + + virtual ~ThriftHiveMetastore_heartbeat_result() noexcept; + NoSuchLockException o1; + NoSuchTxnException o2; + TxnAbortedException o3; + + _ThriftHiveMetastore_heartbeat_result__isset __isset; + + void __set_o1(const NoSuchLockException& val); + + void __set_o2(const NoSuchTxnException& val); + + void __set_o3(const TxnAbortedException& val); + + bool operator == (const ThriftHiveMetastore_heartbeat_result & rhs) const; + bool operator != (const ThriftHiveMetastore_heartbeat_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_heartbeat_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_heartbeat_presult__isset { + _ThriftHiveMetastore_heartbeat_presult__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_heartbeat_presult__isset; + +class ThriftHiveMetastore_heartbeat_presult { + public: + + + virtual ~ThriftHiveMetastore_heartbeat_presult() noexcept; + NoSuchLockException o1; + NoSuchTxnException o2; + TxnAbortedException o3; + + _ThriftHiveMetastore_heartbeat_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_heartbeat_txn_range_args__isset { + _ThriftHiveMetastore_heartbeat_txn_range_args__isset() : txns(false) {} + bool txns :1; +} _ThriftHiveMetastore_heartbeat_txn_range_args__isset; + +class ThriftHiveMetastore_heartbeat_txn_range_args { + public: + + ThriftHiveMetastore_heartbeat_txn_range_args(const ThriftHiveMetastore_heartbeat_txn_range_args&) noexcept; + ThriftHiveMetastore_heartbeat_txn_range_args& operator=(const ThriftHiveMetastore_heartbeat_txn_range_args&) noexcept; + ThriftHiveMetastore_heartbeat_txn_range_args() noexcept; + + virtual ~ThriftHiveMetastore_heartbeat_txn_range_args() noexcept; + HeartbeatTxnRangeRequest txns; + + _ThriftHiveMetastore_heartbeat_txn_range_args__isset __isset; + + void __set_txns(const HeartbeatTxnRangeRequest& val); + + bool operator == (const ThriftHiveMetastore_heartbeat_txn_range_args & rhs) const; + bool operator != (const ThriftHiveMetastore_heartbeat_txn_range_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_heartbeat_txn_range_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_heartbeat_txn_range_pargs { + public: + + + virtual ~ThriftHiveMetastore_heartbeat_txn_range_pargs() noexcept; + const HeartbeatTxnRangeRequest* txns; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_heartbeat_txn_range_result__isset { + _ThriftHiveMetastore_heartbeat_txn_range_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_heartbeat_txn_range_result__isset; + +class ThriftHiveMetastore_heartbeat_txn_range_result { + public: + + ThriftHiveMetastore_heartbeat_txn_range_result(const ThriftHiveMetastore_heartbeat_txn_range_result&); + ThriftHiveMetastore_heartbeat_txn_range_result& operator=(const ThriftHiveMetastore_heartbeat_txn_range_result&); + ThriftHiveMetastore_heartbeat_txn_range_result() noexcept; + + virtual ~ThriftHiveMetastore_heartbeat_txn_range_result() noexcept; + HeartbeatTxnRangeResponse success; + + _ThriftHiveMetastore_heartbeat_txn_range_result__isset __isset; + + void __set_success(const HeartbeatTxnRangeResponse& val); + + bool operator == (const ThriftHiveMetastore_heartbeat_txn_range_result & rhs) const; + bool operator != (const ThriftHiveMetastore_heartbeat_txn_range_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_heartbeat_txn_range_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_heartbeat_txn_range_presult__isset { + _ThriftHiveMetastore_heartbeat_txn_range_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_heartbeat_txn_range_presult__isset; + +class ThriftHiveMetastore_heartbeat_txn_range_presult { + public: + + + virtual ~ThriftHiveMetastore_heartbeat_txn_range_presult() noexcept; + HeartbeatTxnRangeResponse* success; + + _ThriftHiveMetastore_heartbeat_txn_range_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_compact_args__isset { + _ThriftHiveMetastore_compact_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_compact_args__isset; + +class ThriftHiveMetastore_compact_args { + public: + + ThriftHiveMetastore_compact_args(const ThriftHiveMetastore_compact_args&); + ThriftHiveMetastore_compact_args& operator=(const ThriftHiveMetastore_compact_args&); + ThriftHiveMetastore_compact_args() noexcept; + + virtual ~ThriftHiveMetastore_compact_args() noexcept; + CompactionRequest rqst; + + _ThriftHiveMetastore_compact_args__isset __isset; + + void __set_rqst(const CompactionRequest& val); + + bool operator == (const ThriftHiveMetastore_compact_args & rhs) const; + bool operator != (const ThriftHiveMetastore_compact_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_compact_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_compact_pargs { + public: + + + virtual ~ThriftHiveMetastore_compact_pargs() noexcept; + const CompactionRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_compact_result { + public: + + ThriftHiveMetastore_compact_result(const ThriftHiveMetastore_compact_result&) noexcept; + ThriftHiveMetastore_compact_result& operator=(const ThriftHiveMetastore_compact_result&) noexcept; + ThriftHiveMetastore_compact_result() noexcept; + + virtual ~ThriftHiveMetastore_compact_result() noexcept; + + bool operator == (const ThriftHiveMetastore_compact_result & /* rhs */) const; + bool operator != (const ThriftHiveMetastore_compact_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_compact_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_compact_presult { + public: + + + virtual ~ThriftHiveMetastore_compact_presult() noexcept; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_compact2_args__isset { + _ThriftHiveMetastore_compact2_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_compact2_args__isset; + +class ThriftHiveMetastore_compact2_args { + public: + + ThriftHiveMetastore_compact2_args(const ThriftHiveMetastore_compact2_args&); + ThriftHiveMetastore_compact2_args& operator=(const ThriftHiveMetastore_compact2_args&); + ThriftHiveMetastore_compact2_args() noexcept; + + virtual ~ThriftHiveMetastore_compact2_args() noexcept; + CompactionRequest rqst; + + _ThriftHiveMetastore_compact2_args__isset __isset; + + void __set_rqst(const CompactionRequest& val); + + bool operator == (const ThriftHiveMetastore_compact2_args & rhs) const; + bool operator != (const ThriftHiveMetastore_compact2_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_compact2_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_compact2_pargs { + public: + + + virtual ~ThriftHiveMetastore_compact2_pargs() noexcept; + const CompactionRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_compact2_result__isset { + _ThriftHiveMetastore_compact2_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_compact2_result__isset; + +class ThriftHiveMetastore_compact2_result { + public: + + ThriftHiveMetastore_compact2_result(const ThriftHiveMetastore_compact2_result&); + ThriftHiveMetastore_compact2_result& operator=(const ThriftHiveMetastore_compact2_result&); + ThriftHiveMetastore_compact2_result() noexcept; + + virtual ~ThriftHiveMetastore_compact2_result() noexcept; + CompactionResponse success; + + _ThriftHiveMetastore_compact2_result__isset __isset; + + void __set_success(const CompactionResponse& val); + + bool operator == (const ThriftHiveMetastore_compact2_result & rhs) const; + bool operator != (const ThriftHiveMetastore_compact2_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_compact2_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_compact2_presult__isset { + _ThriftHiveMetastore_compact2_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_compact2_presult__isset; + +class ThriftHiveMetastore_compact2_presult { + public: + + + virtual ~ThriftHiveMetastore_compact2_presult() noexcept; + CompactionResponse* success; + + _ThriftHiveMetastore_compact2_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_show_compact_args__isset { + _ThriftHiveMetastore_show_compact_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_show_compact_args__isset; + +class ThriftHiveMetastore_show_compact_args { + public: + + ThriftHiveMetastore_show_compact_args(const ThriftHiveMetastore_show_compact_args&); + ThriftHiveMetastore_show_compact_args& operator=(const ThriftHiveMetastore_show_compact_args&); + ThriftHiveMetastore_show_compact_args() noexcept; + + virtual ~ThriftHiveMetastore_show_compact_args() noexcept; + ShowCompactRequest rqst; + + _ThriftHiveMetastore_show_compact_args__isset __isset; + + void __set_rqst(const ShowCompactRequest& val); + + bool operator == (const ThriftHiveMetastore_show_compact_args & rhs) const; + bool operator != (const ThriftHiveMetastore_show_compact_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_show_compact_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_show_compact_pargs { + public: + + + virtual ~ThriftHiveMetastore_show_compact_pargs() noexcept; + const ShowCompactRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_show_compact_result__isset { + _ThriftHiveMetastore_show_compact_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_show_compact_result__isset; + +class ThriftHiveMetastore_show_compact_result { + public: + + ThriftHiveMetastore_show_compact_result(const ThriftHiveMetastore_show_compact_result&); + ThriftHiveMetastore_show_compact_result& operator=(const ThriftHiveMetastore_show_compact_result&); + ThriftHiveMetastore_show_compact_result() noexcept; + + virtual ~ThriftHiveMetastore_show_compact_result() noexcept; + ShowCompactResponse success; + + _ThriftHiveMetastore_show_compact_result__isset __isset; + + void __set_success(const ShowCompactResponse& val); + + bool operator == (const ThriftHiveMetastore_show_compact_result & rhs) const; + bool operator != (const ThriftHiveMetastore_show_compact_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_show_compact_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_show_compact_presult__isset { + _ThriftHiveMetastore_show_compact_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_show_compact_presult__isset; + +class ThriftHiveMetastore_show_compact_presult { + public: + + + virtual ~ThriftHiveMetastore_show_compact_presult() noexcept; + ShowCompactResponse* success; + + _ThriftHiveMetastore_show_compact_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_submit_for_cleanup_args__isset { + _ThriftHiveMetastore_submit_for_cleanup_args__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_submit_for_cleanup_args__isset; + +class ThriftHiveMetastore_submit_for_cleanup_args { + public: + + ThriftHiveMetastore_submit_for_cleanup_args(const ThriftHiveMetastore_submit_for_cleanup_args&); + ThriftHiveMetastore_submit_for_cleanup_args& operator=(const ThriftHiveMetastore_submit_for_cleanup_args&); + ThriftHiveMetastore_submit_for_cleanup_args() noexcept; + + virtual ~ThriftHiveMetastore_submit_for_cleanup_args() noexcept; + CompactionRequest o1; + int64_t o2; + int64_t o3; + + _ThriftHiveMetastore_submit_for_cleanup_args__isset __isset; + + void __set_o1(const CompactionRequest& val); + + void __set_o2(const int64_t val); + + void __set_o3(const int64_t val); + + bool operator == (const ThriftHiveMetastore_submit_for_cleanup_args & rhs) const; + bool operator != (const ThriftHiveMetastore_submit_for_cleanup_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_submit_for_cleanup_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_submit_for_cleanup_pargs { + public: + + + virtual ~ThriftHiveMetastore_submit_for_cleanup_pargs() noexcept; + const CompactionRequest* o1; + const int64_t* o2; + const int64_t* o3; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_submit_for_cleanup_result__isset { + _ThriftHiveMetastore_submit_for_cleanup_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_submit_for_cleanup_result__isset; + +class ThriftHiveMetastore_submit_for_cleanup_result { + public: + + ThriftHiveMetastore_submit_for_cleanup_result(const ThriftHiveMetastore_submit_for_cleanup_result&); + ThriftHiveMetastore_submit_for_cleanup_result& operator=(const ThriftHiveMetastore_submit_for_cleanup_result&); + ThriftHiveMetastore_submit_for_cleanup_result() noexcept; + + virtual ~ThriftHiveMetastore_submit_for_cleanup_result() noexcept; + bool success; + MetaException o1; + + _ThriftHiveMetastore_submit_for_cleanup_result__isset __isset; + + void __set_success(const bool val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_submit_for_cleanup_result & rhs) const; + bool operator != (const ThriftHiveMetastore_submit_for_cleanup_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_submit_for_cleanup_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_submit_for_cleanup_presult__isset { + _ThriftHiveMetastore_submit_for_cleanup_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_submit_for_cleanup_presult__isset; + +class ThriftHiveMetastore_submit_for_cleanup_presult { + public: + + + virtual ~ThriftHiveMetastore_submit_for_cleanup_presult() noexcept; + bool* success; + MetaException o1; + + _ThriftHiveMetastore_submit_for_cleanup_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_add_dynamic_partitions_args__isset { + _ThriftHiveMetastore_add_dynamic_partitions_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_add_dynamic_partitions_args__isset; + +class ThriftHiveMetastore_add_dynamic_partitions_args { + public: + + ThriftHiveMetastore_add_dynamic_partitions_args(const ThriftHiveMetastore_add_dynamic_partitions_args&); + ThriftHiveMetastore_add_dynamic_partitions_args& operator=(const ThriftHiveMetastore_add_dynamic_partitions_args&); + ThriftHiveMetastore_add_dynamic_partitions_args() noexcept; + + virtual ~ThriftHiveMetastore_add_dynamic_partitions_args() noexcept; + AddDynamicPartitions rqst; + + _ThriftHiveMetastore_add_dynamic_partitions_args__isset __isset; + + void __set_rqst(const AddDynamicPartitions& val); + + bool operator == (const ThriftHiveMetastore_add_dynamic_partitions_args & rhs) const; + bool operator != (const ThriftHiveMetastore_add_dynamic_partitions_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_dynamic_partitions_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_dynamic_partitions_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_dynamic_partitions_pargs() noexcept; + const AddDynamicPartitions* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_dynamic_partitions_result__isset { + _ThriftHiveMetastore_add_dynamic_partitions_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_add_dynamic_partitions_result__isset; + +class ThriftHiveMetastore_add_dynamic_partitions_result { + public: + + ThriftHiveMetastore_add_dynamic_partitions_result(const ThriftHiveMetastore_add_dynamic_partitions_result&); + ThriftHiveMetastore_add_dynamic_partitions_result& operator=(const ThriftHiveMetastore_add_dynamic_partitions_result&); + ThriftHiveMetastore_add_dynamic_partitions_result() noexcept; + + virtual ~ThriftHiveMetastore_add_dynamic_partitions_result() noexcept; + NoSuchTxnException o1; + TxnAbortedException o2; + + _ThriftHiveMetastore_add_dynamic_partitions_result__isset __isset; + + void __set_o1(const NoSuchTxnException& val); + + void __set_o2(const TxnAbortedException& val); + + bool operator == (const ThriftHiveMetastore_add_dynamic_partitions_result & rhs) const; + bool operator != (const ThriftHiveMetastore_add_dynamic_partitions_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_dynamic_partitions_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_dynamic_partitions_presult__isset { + _ThriftHiveMetastore_add_dynamic_partitions_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_add_dynamic_partitions_presult__isset; + +class ThriftHiveMetastore_add_dynamic_partitions_presult { + public: + + + virtual ~ThriftHiveMetastore_add_dynamic_partitions_presult() noexcept; + NoSuchTxnException o1; + TxnAbortedException o2; + + _ThriftHiveMetastore_add_dynamic_partitions_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_find_next_compact_args__isset { + _ThriftHiveMetastore_find_next_compact_args__isset() : workerId(false) {} + bool workerId :1; +} _ThriftHiveMetastore_find_next_compact_args__isset; + +class ThriftHiveMetastore_find_next_compact_args { + public: + + ThriftHiveMetastore_find_next_compact_args(const ThriftHiveMetastore_find_next_compact_args&); + ThriftHiveMetastore_find_next_compact_args& operator=(const ThriftHiveMetastore_find_next_compact_args&); + ThriftHiveMetastore_find_next_compact_args() noexcept; + + virtual ~ThriftHiveMetastore_find_next_compact_args() noexcept; + std::string workerId; + + _ThriftHiveMetastore_find_next_compact_args__isset __isset; + + void __set_workerId(const std::string& val); + + bool operator == (const ThriftHiveMetastore_find_next_compact_args & rhs) const; + bool operator != (const ThriftHiveMetastore_find_next_compact_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_find_next_compact_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_find_next_compact_pargs { + public: + + + virtual ~ThriftHiveMetastore_find_next_compact_pargs() noexcept; + const std::string* workerId; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_find_next_compact_result__isset { + _ThriftHiveMetastore_find_next_compact_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_find_next_compact_result__isset; + +class ThriftHiveMetastore_find_next_compact_result { + public: + + ThriftHiveMetastore_find_next_compact_result(const ThriftHiveMetastore_find_next_compact_result&); + ThriftHiveMetastore_find_next_compact_result& operator=(const ThriftHiveMetastore_find_next_compact_result&); + ThriftHiveMetastore_find_next_compact_result() noexcept; + + virtual ~ThriftHiveMetastore_find_next_compact_result() noexcept; + OptionalCompactionInfoStruct success; + MetaException o1; + + _ThriftHiveMetastore_find_next_compact_result__isset __isset; + + void __set_success(const OptionalCompactionInfoStruct& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_find_next_compact_result & rhs) const; + bool operator != (const ThriftHiveMetastore_find_next_compact_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_find_next_compact_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_find_next_compact_presult__isset { + _ThriftHiveMetastore_find_next_compact_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_find_next_compact_presult__isset; + +class ThriftHiveMetastore_find_next_compact_presult { + public: + + + virtual ~ThriftHiveMetastore_find_next_compact_presult() noexcept; + OptionalCompactionInfoStruct* success; + MetaException o1; + + _ThriftHiveMetastore_find_next_compact_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_find_next_compact2_args__isset { + _ThriftHiveMetastore_find_next_compact2_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_find_next_compact2_args__isset; + +class ThriftHiveMetastore_find_next_compact2_args { + public: + + ThriftHiveMetastore_find_next_compact2_args(const ThriftHiveMetastore_find_next_compact2_args&); + ThriftHiveMetastore_find_next_compact2_args& operator=(const ThriftHiveMetastore_find_next_compact2_args&); + ThriftHiveMetastore_find_next_compact2_args() noexcept; + + virtual ~ThriftHiveMetastore_find_next_compact2_args() noexcept; + FindNextCompactRequest rqst; + + _ThriftHiveMetastore_find_next_compact2_args__isset __isset; + + void __set_rqst(const FindNextCompactRequest& val); + + bool operator == (const ThriftHiveMetastore_find_next_compact2_args & rhs) const; + bool operator != (const ThriftHiveMetastore_find_next_compact2_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_find_next_compact2_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_find_next_compact2_pargs { + public: + + + virtual ~ThriftHiveMetastore_find_next_compact2_pargs() noexcept; + const FindNextCompactRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_find_next_compact2_result__isset { + _ThriftHiveMetastore_find_next_compact2_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_find_next_compact2_result__isset; + +class ThriftHiveMetastore_find_next_compact2_result { + public: + + ThriftHiveMetastore_find_next_compact2_result(const ThriftHiveMetastore_find_next_compact2_result&); + ThriftHiveMetastore_find_next_compact2_result& operator=(const ThriftHiveMetastore_find_next_compact2_result&); + ThriftHiveMetastore_find_next_compact2_result() noexcept; + + virtual ~ThriftHiveMetastore_find_next_compact2_result() noexcept; + OptionalCompactionInfoStruct success; + MetaException o1; + + _ThriftHiveMetastore_find_next_compact2_result__isset __isset; + + void __set_success(const OptionalCompactionInfoStruct& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_find_next_compact2_result & rhs) const; + bool operator != (const ThriftHiveMetastore_find_next_compact2_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_find_next_compact2_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_find_next_compact2_presult__isset { + _ThriftHiveMetastore_find_next_compact2_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_find_next_compact2_presult__isset; + +class ThriftHiveMetastore_find_next_compact2_presult { + public: + + + virtual ~ThriftHiveMetastore_find_next_compact2_presult() noexcept; + OptionalCompactionInfoStruct* success; + MetaException o1; + + _ThriftHiveMetastore_find_next_compact2_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_update_compactor_state_args__isset { + _ThriftHiveMetastore_update_compactor_state_args__isset() : cr(false), txn_id(false) {} + bool cr :1; + bool txn_id :1; +} _ThriftHiveMetastore_update_compactor_state_args__isset; + +class ThriftHiveMetastore_update_compactor_state_args { + public: + + ThriftHiveMetastore_update_compactor_state_args(const ThriftHiveMetastore_update_compactor_state_args&); + ThriftHiveMetastore_update_compactor_state_args& operator=(const ThriftHiveMetastore_update_compactor_state_args&); + ThriftHiveMetastore_update_compactor_state_args() noexcept; + + virtual ~ThriftHiveMetastore_update_compactor_state_args() noexcept; + CompactionInfoStruct cr; + int64_t txn_id; + + _ThriftHiveMetastore_update_compactor_state_args__isset __isset; + + void __set_cr(const CompactionInfoStruct& val); + + void __set_txn_id(const int64_t val); + + bool operator == (const ThriftHiveMetastore_update_compactor_state_args & rhs) const; + bool operator != (const ThriftHiveMetastore_update_compactor_state_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_update_compactor_state_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_update_compactor_state_pargs { + public: + + + virtual ~ThriftHiveMetastore_update_compactor_state_pargs() noexcept; + const CompactionInfoStruct* cr; + const int64_t* txn_id; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_update_compactor_state_result { + public: + + ThriftHiveMetastore_update_compactor_state_result(const ThriftHiveMetastore_update_compactor_state_result&) noexcept; + ThriftHiveMetastore_update_compactor_state_result& operator=(const ThriftHiveMetastore_update_compactor_state_result&) noexcept; + ThriftHiveMetastore_update_compactor_state_result() noexcept; + + virtual ~ThriftHiveMetastore_update_compactor_state_result() noexcept; + + bool operator == (const ThriftHiveMetastore_update_compactor_state_result & /* rhs */) const; + bool operator != (const ThriftHiveMetastore_update_compactor_state_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_update_compactor_state_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_update_compactor_state_presult { + public: + + + virtual ~ThriftHiveMetastore_update_compactor_state_presult() noexcept; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_find_columns_with_stats_args__isset { + _ThriftHiveMetastore_find_columns_with_stats_args__isset() : cr(false) {} + bool cr :1; +} _ThriftHiveMetastore_find_columns_with_stats_args__isset; + +class ThriftHiveMetastore_find_columns_with_stats_args { + public: + + ThriftHiveMetastore_find_columns_with_stats_args(const ThriftHiveMetastore_find_columns_with_stats_args&); + ThriftHiveMetastore_find_columns_with_stats_args& operator=(const ThriftHiveMetastore_find_columns_with_stats_args&); + ThriftHiveMetastore_find_columns_with_stats_args() noexcept; + + virtual ~ThriftHiveMetastore_find_columns_with_stats_args() noexcept; + CompactionInfoStruct cr; + + _ThriftHiveMetastore_find_columns_with_stats_args__isset __isset; + + void __set_cr(const CompactionInfoStruct& val); + + bool operator == (const ThriftHiveMetastore_find_columns_with_stats_args & rhs) const; + bool operator != (const ThriftHiveMetastore_find_columns_with_stats_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_find_columns_with_stats_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_find_columns_with_stats_pargs { + public: + + + virtual ~ThriftHiveMetastore_find_columns_with_stats_pargs() noexcept; + const CompactionInfoStruct* cr; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_find_columns_with_stats_result__isset { + _ThriftHiveMetastore_find_columns_with_stats_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_find_columns_with_stats_result__isset; + +class ThriftHiveMetastore_find_columns_with_stats_result { + public: + + ThriftHiveMetastore_find_columns_with_stats_result(const ThriftHiveMetastore_find_columns_with_stats_result&); + ThriftHiveMetastore_find_columns_with_stats_result& operator=(const ThriftHiveMetastore_find_columns_with_stats_result&); + ThriftHiveMetastore_find_columns_with_stats_result() noexcept; + + virtual ~ThriftHiveMetastore_find_columns_with_stats_result() noexcept; + std::vector success; + + _ThriftHiveMetastore_find_columns_with_stats_result__isset __isset; + + void __set_success(const std::vector & val); + + bool operator == (const ThriftHiveMetastore_find_columns_with_stats_result & rhs) const; + bool operator != (const ThriftHiveMetastore_find_columns_with_stats_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_find_columns_with_stats_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_find_columns_with_stats_presult__isset { + _ThriftHiveMetastore_find_columns_with_stats_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_find_columns_with_stats_presult__isset; + +class ThriftHiveMetastore_find_columns_with_stats_presult { + public: + + + virtual ~ThriftHiveMetastore_find_columns_with_stats_presult() noexcept; + std::vector * success; + + _ThriftHiveMetastore_find_columns_with_stats_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_mark_cleaned_args__isset { + _ThriftHiveMetastore_mark_cleaned_args__isset() : cr(false) {} + bool cr :1; +} _ThriftHiveMetastore_mark_cleaned_args__isset; + +class ThriftHiveMetastore_mark_cleaned_args { + public: + + ThriftHiveMetastore_mark_cleaned_args(const ThriftHiveMetastore_mark_cleaned_args&); + ThriftHiveMetastore_mark_cleaned_args& operator=(const ThriftHiveMetastore_mark_cleaned_args&); + ThriftHiveMetastore_mark_cleaned_args() noexcept; + + virtual ~ThriftHiveMetastore_mark_cleaned_args() noexcept; + CompactionInfoStruct cr; + + _ThriftHiveMetastore_mark_cleaned_args__isset __isset; + + void __set_cr(const CompactionInfoStruct& val); + + bool operator == (const ThriftHiveMetastore_mark_cleaned_args & rhs) const; + bool operator != (const ThriftHiveMetastore_mark_cleaned_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_mark_cleaned_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_mark_cleaned_pargs { + public: + + + virtual ~ThriftHiveMetastore_mark_cleaned_pargs() noexcept; + const CompactionInfoStruct* cr; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_mark_cleaned_result__isset { + _ThriftHiveMetastore_mark_cleaned_result__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_mark_cleaned_result__isset; + +class ThriftHiveMetastore_mark_cleaned_result { + public: + + ThriftHiveMetastore_mark_cleaned_result(const ThriftHiveMetastore_mark_cleaned_result&); + ThriftHiveMetastore_mark_cleaned_result& operator=(const ThriftHiveMetastore_mark_cleaned_result&); + ThriftHiveMetastore_mark_cleaned_result() noexcept; + + virtual ~ThriftHiveMetastore_mark_cleaned_result() noexcept; + MetaException o1; + + _ThriftHiveMetastore_mark_cleaned_result__isset __isset; + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_mark_cleaned_result & rhs) const; + bool operator != (const ThriftHiveMetastore_mark_cleaned_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_mark_cleaned_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_mark_cleaned_presult__isset { + _ThriftHiveMetastore_mark_cleaned_presult__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_mark_cleaned_presult__isset; + +class ThriftHiveMetastore_mark_cleaned_presult { + public: + + + virtual ~ThriftHiveMetastore_mark_cleaned_presult() noexcept; + MetaException o1; + + _ThriftHiveMetastore_mark_cleaned_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_mark_compacted_args__isset { + _ThriftHiveMetastore_mark_compacted_args__isset() : cr(false) {} + bool cr :1; +} _ThriftHiveMetastore_mark_compacted_args__isset; + +class ThriftHiveMetastore_mark_compacted_args { + public: + + ThriftHiveMetastore_mark_compacted_args(const ThriftHiveMetastore_mark_compacted_args&); + ThriftHiveMetastore_mark_compacted_args& operator=(const ThriftHiveMetastore_mark_compacted_args&); + ThriftHiveMetastore_mark_compacted_args() noexcept; + + virtual ~ThriftHiveMetastore_mark_compacted_args() noexcept; + CompactionInfoStruct cr; + + _ThriftHiveMetastore_mark_compacted_args__isset __isset; + + void __set_cr(const CompactionInfoStruct& val); + + bool operator == (const ThriftHiveMetastore_mark_compacted_args & rhs) const; + bool operator != (const ThriftHiveMetastore_mark_compacted_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_mark_compacted_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_mark_compacted_pargs { + public: + + + virtual ~ThriftHiveMetastore_mark_compacted_pargs() noexcept; + const CompactionInfoStruct* cr; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_mark_compacted_result__isset { + _ThriftHiveMetastore_mark_compacted_result__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_mark_compacted_result__isset; + +class ThriftHiveMetastore_mark_compacted_result { + public: + + ThriftHiveMetastore_mark_compacted_result(const ThriftHiveMetastore_mark_compacted_result&); + ThriftHiveMetastore_mark_compacted_result& operator=(const ThriftHiveMetastore_mark_compacted_result&); + ThriftHiveMetastore_mark_compacted_result() noexcept; + + virtual ~ThriftHiveMetastore_mark_compacted_result() noexcept; + MetaException o1; + + _ThriftHiveMetastore_mark_compacted_result__isset __isset; + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_mark_compacted_result & rhs) const; + bool operator != (const ThriftHiveMetastore_mark_compacted_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_mark_compacted_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_mark_compacted_presult__isset { + _ThriftHiveMetastore_mark_compacted_presult__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_mark_compacted_presult__isset; + +class ThriftHiveMetastore_mark_compacted_presult { + public: + + + virtual ~ThriftHiveMetastore_mark_compacted_presult() noexcept; + MetaException o1; + + _ThriftHiveMetastore_mark_compacted_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_mark_failed_args__isset { + _ThriftHiveMetastore_mark_failed_args__isset() : cr(false) {} + bool cr :1; +} _ThriftHiveMetastore_mark_failed_args__isset; + +class ThriftHiveMetastore_mark_failed_args { + public: + + ThriftHiveMetastore_mark_failed_args(const ThriftHiveMetastore_mark_failed_args&); + ThriftHiveMetastore_mark_failed_args& operator=(const ThriftHiveMetastore_mark_failed_args&); + ThriftHiveMetastore_mark_failed_args() noexcept; + + virtual ~ThriftHiveMetastore_mark_failed_args() noexcept; + CompactionInfoStruct cr; + + _ThriftHiveMetastore_mark_failed_args__isset __isset; + + void __set_cr(const CompactionInfoStruct& val); + + bool operator == (const ThriftHiveMetastore_mark_failed_args & rhs) const; + bool operator != (const ThriftHiveMetastore_mark_failed_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_mark_failed_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_mark_failed_pargs { + public: + + + virtual ~ThriftHiveMetastore_mark_failed_pargs() noexcept; + const CompactionInfoStruct* cr; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_mark_failed_result__isset { + _ThriftHiveMetastore_mark_failed_result__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_mark_failed_result__isset; + +class ThriftHiveMetastore_mark_failed_result { + public: + + ThriftHiveMetastore_mark_failed_result(const ThriftHiveMetastore_mark_failed_result&); + ThriftHiveMetastore_mark_failed_result& operator=(const ThriftHiveMetastore_mark_failed_result&); + ThriftHiveMetastore_mark_failed_result() noexcept; + + virtual ~ThriftHiveMetastore_mark_failed_result() noexcept; + MetaException o1; + + _ThriftHiveMetastore_mark_failed_result__isset __isset; + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_mark_failed_result & rhs) const; + bool operator != (const ThriftHiveMetastore_mark_failed_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_mark_failed_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_mark_failed_presult__isset { + _ThriftHiveMetastore_mark_failed_presult__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_mark_failed_presult__isset; + +class ThriftHiveMetastore_mark_failed_presult { + public: + + + virtual ~ThriftHiveMetastore_mark_failed_presult() noexcept; + MetaException o1; + + _ThriftHiveMetastore_mark_failed_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_mark_refused_args__isset { + _ThriftHiveMetastore_mark_refused_args__isset() : cr(false) {} + bool cr :1; +} _ThriftHiveMetastore_mark_refused_args__isset; + +class ThriftHiveMetastore_mark_refused_args { + public: + + ThriftHiveMetastore_mark_refused_args(const ThriftHiveMetastore_mark_refused_args&); + ThriftHiveMetastore_mark_refused_args& operator=(const ThriftHiveMetastore_mark_refused_args&); + ThriftHiveMetastore_mark_refused_args() noexcept; + + virtual ~ThriftHiveMetastore_mark_refused_args() noexcept; + CompactionInfoStruct cr; + + _ThriftHiveMetastore_mark_refused_args__isset __isset; + + void __set_cr(const CompactionInfoStruct& val); + + bool operator == (const ThriftHiveMetastore_mark_refused_args & rhs) const; + bool operator != (const ThriftHiveMetastore_mark_refused_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_mark_refused_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_mark_refused_pargs { + public: + + + virtual ~ThriftHiveMetastore_mark_refused_pargs() noexcept; + const CompactionInfoStruct* cr; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_mark_refused_result__isset { + _ThriftHiveMetastore_mark_refused_result__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_mark_refused_result__isset; + +class ThriftHiveMetastore_mark_refused_result { + public: + + ThriftHiveMetastore_mark_refused_result(const ThriftHiveMetastore_mark_refused_result&); + ThriftHiveMetastore_mark_refused_result& operator=(const ThriftHiveMetastore_mark_refused_result&); + ThriftHiveMetastore_mark_refused_result() noexcept; + + virtual ~ThriftHiveMetastore_mark_refused_result() noexcept; + MetaException o1; + + _ThriftHiveMetastore_mark_refused_result__isset __isset; + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_mark_refused_result & rhs) const; + bool operator != (const ThriftHiveMetastore_mark_refused_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_mark_refused_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_mark_refused_presult__isset { + _ThriftHiveMetastore_mark_refused_presult__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_mark_refused_presult__isset; + +class ThriftHiveMetastore_mark_refused_presult { + public: + + + virtual ~ThriftHiveMetastore_mark_refused_presult() noexcept; + MetaException o1; + + _ThriftHiveMetastore_mark_refused_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_update_compaction_metrics_data_args__isset { + _ThriftHiveMetastore_update_compaction_metrics_data_args__isset() : data(false) {} + bool data :1; +} _ThriftHiveMetastore_update_compaction_metrics_data_args__isset; + +class ThriftHiveMetastore_update_compaction_metrics_data_args { + public: + + ThriftHiveMetastore_update_compaction_metrics_data_args(const ThriftHiveMetastore_update_compaction_metrics_data_args&); + ThriftHiveMetastore_update_compaction_metrics_data_args& operator=(const ThriftHiveMetastore_update_compaction_metrics_data_args&); + ThriftHiveMetastore_update_compaction_metrics_data_args() noexcept; + + virtual ~ThriftHiveMetastore_update_compaction_metrics_data_args() noexcept; + CompactionMetricsDataStruct data; + + _ThriftHiveMetastore_update_compaction_metrics_data_args__isset __isset; + + void __set_data(const CompactionMetricsDataStruct& val); + + bool operator == (const ThriftHiveMetastore_update_compaction_metrics_data_args & rhs) const; + bool operator != (const ThriftHiveMetastore_update_compaction_metrics_data_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_update_compaction_metrics_data_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_update_compaction_metrics_data_pargs { + public: + + + virtual ~ThriftHiveMetastore_update_compaction_metrics_data_pargs() noexcept; + const CompactionMetricsDataStruct* data; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_update_compaction_metrics_data_result__isset { + _ThriftHiveMetastore_update_compaction_metrics_data_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_update_compaction_metrics_data_result__isset; + +class ThriftHiveMetastore_update_compaction_metrics_data_result { + public: + + ThriftHiveMetastore_update_compaction_metrics_data_result(const ThriftHiveMetastore_update_compaction_metrics_data_result&); + ThriftHiveMetastore_update_compaction_metrics_data_result& operator=(const ThriftHiveMetastore_update_compaction_metrics_data_result&); + ThriftHiveMetastore_update_compaction_metrics_data_result() noexcept; + + virtual ~ThriftHiveMetastore_update_compaction_metrics_data_result() noexcept; + bool success; + MetaException o1; + + _ThriftHiveMetastore_update_compaction_metrics_data_result__isset __isset; + + void __set_success(const bool val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_update_compaction_metrics_data_result & rhs) const; + bool operator != (const ThriftHiveMetastore_update_compaction_metrics_data_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_update_compaction_metrics_data_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_update_compaction_metrics_data_presult__isset { + _ThriftHiveMetastore_update_compaction_metrics_data_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_update_compaction_metrics_data_presult__isset; + +class ThriftHiveMetastore_update_compaction_metrics_data_presult { + public: + + + virtual ~ThriftHiveMetastore_update_compaction_metrics_data_presult() noexcept; + bool* success; + MetaException o1; + + _ThriftHiveMetastore_update_compaction_metrics_data_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_remove_compaction_metrics_data_args__isset { + _ThriftHiveMetastore_remove_compaction_metrics_data_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_remove_compaction_metrics_data_args__isset; + +class ThriftHiveMetastore_remove_compaction_metrics_data_args { + public: + + ThriftHiveMetastore_remove_compaction_metrics_data_args(const ThriftHiveMetastore_remove_compaction_metrics_data_args&); + ThriftHiveMetastore_remove_compaction_metrics_data_args& operator=(const ThriftHiveMetastore_remove_compaction_metrics_data_args&); + ThriftHiveMetastore_remove_compaction_metrics_data_args() noexcept; + + virtual ~ThriftHiveMetastore_remove_compaction_metrics_data_args() noexcept; + CompactionMetricsDataRequest request; + + _ThriftHiveMetastore_remove_compaction_metrics_data_args__isset __isset; + + void __set_request(const CompactionMetricsDataRequest& val); + + bool operator == (const ThriftHiveMetastore_remove_compaction_metrics_data_args & rhs) const; + bool operator != (const ThriftHiveMetastore_remove_compaction_metrics_data_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_remove_compaction_metrics_data_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_remove_compaction_metrics_data_pargs { + public: + + + virtual ~ThriftHiveMetastore_remove_compaction_metrics_data_pargs() noexcept; + const CompactionMetricsDataRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_remove_compaction_metrics_data_result__isset { + _ThriftHiveMetastore_remove_compaction_metrics_data_result__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_remove_compaction_metrics_data_result__isset; + +class ThriftHiveMetastore_remove_compaction_metrics_data_result { + public: + + ThriftHiveMetastore_remove_compaction_metrics_data_result(const ThriftHiveMetastore_remove_compaction_metrics_data_result&); + ThriftHiveMetastore_remove_compaction_metrics_data_result& operator=(const ThriftHiveMetastore_remove_compaction_metrics_data_result&); + ThriftHiveMetastore_remove_compaction_metrics_data_result() noexcept; + + virtual ~ThriftHiveMetastore_remove_compaction_metrics_data_result() noexcept; + MetaException o1; + + _ThriftHiveMetastore_remove_compaction_metrics_data_result__isset __isset; + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_remove_compaction_metrics_data_result & rhs) const; + bool operator != (const ThriftHiveMetastore_remove_compaction_metrics_data_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_remove_compaction_metrics_data_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_remove_compaction_metrics_data_presult__isset { + _ThriftHiveMetastore_remove_compaction_metrics_data_presult__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_remove_compaction_metrics_data_presult__isset; + +class ThriftHiveMetastore_remove_compaction_metrics_data_presult { + public: + + + virtual ~ThriftHiveMetastore_remove_compaction_metrics_data_presult() noexcept; + MetaException o1; + + _ThriftHiveMetastore_remove_compaction_metrics_data_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_set_hadoop_jobid_args__isset { + _ThriftHiveMetastore_set_hadoop_jobid_args__isset() : jobId(false), cq_id(false) {} + bool jobId :1; + bool cq_id :1; +} _ThriftHiveMetastore_set_hadoop_jobid_args__isset; + +class ThriftHiveMetastore_set_hadoop_jobid_args { + public: + + ThriftHiveMetastore_set_hadoop_jobid_args(const ThriftHiveMetastore_set_hadoop_jobid_args&); + ThriftHiveMetastore_set_hadoop_jobid_args& operator=(const ThriftHiveMetastore_set_hadoop_jobid_args&); + ThriftHiveMetastore_set_hadoop_jobid_args() noexcept; + + virtual ~ThriftHiveMetastore_set_hadoop_jobid_args() noexcept; + std::string jobId; + int64_t cq_id; + + _ThriftHiveMetastore_set_hadoop_jobid_args__isset __isset; + + void __set_jobId(const std::string& val); + + void __set_cq_id(const int64_t val); + + bool operator == (const ThriftHiveMetastore_set_hadoop_jobid_args & rhs) const; + bool operator != (const ThriftHiveMetastore_set_hadoop_jobid_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_set_hadoop_jobid_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_set_hadoop_jobid_pargs { + public: + + + virtual ~ThriftHiveMetastore_set_hadoop_jobid_pargs() noexcept; + const std::string* jobId; + const int64_t* cq_id; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_set_hadoop_jobid_result { + public: + + ThriftHiveMetastore_set_hadoop_jobid_result(const ThriftHiveMetastore_set_hadoop_jobid_result&) noexcept; + ThriftHiveMetastore_set_hadoop_jobid_result& operator=(const ThriftHiveMetastore_set_hadoop_jobid_result&) noexcept; + ThriftHiveMetastore_set_hadoop_jobid_result() noexcept; + + virtual ~ThriftHiveMetastore_set_hadoop_jobid_result() noexcept; + + bool operator == (const ThriftHiveMetastore_set_hadoop_jobid_result & /* rhs */) const; + bool operator != (const ThriftHiveMetastore_set_hadoop_jobid_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_set_hadoop_jobid_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_set_hadoop_jobid_presult { + public: + + + virtual ~ThriftHiveMetastore_set_hadoop_jobid_presult() noexcept; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_latest_committed_compaction_info_args__isset { + _ThriftHiveMetastore_get_latest_committed_compaction_info_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_get_latest_committed_compaction_info_args__isset; + +class ThriftHiveMetastore_get_latest_committed_compaction_info_args { + public: + + ThriftHiveMetastore_get_latest_committed_compaction_info_args(const ThriftHiveMetastore_get_latest_committed_compaction_info_args&); + ThriftHiveMetastore_get_latest_committed_compaction_info_args& operator=(const ThriftHiveMetastore_get_latest_committed_compaction_info_args&); + ThriftHiveMetastore_get_latest_committed_compaction_info_args() noexcept; + + virtual ~ThriftHiveMetastore_get_latest_committed_compaction_info_args() noexcept; + GetLatestCommittedCompactionInfoRequest rqst; + + _ThriftHiveMetastore_get_latest_committed_compaction_info_args__isset __isset; + + void __set_rqst(const GetLatestCommittedCompactionInfoRequest& val); + + bool operator == (const ThriftHiveMetastore_get_latest_committed_compaction_info_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_latest_committed_compaction_info_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_latest_committed_compaction_info_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_latest_committed_compaction_info_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_latest_committed_compaction_info_pargs() noexcept; + const GetLatestCommittedCompactionInfoRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_latest_committed_compaction_info_result__isset { + _ThriftHiveMetastore_get_latest_committed_compaction_info_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_latest_committed_compaction_info_result__isset; + +class ThriftHiveMetastore_get_latest_committed_compaction_info_result { + public: + + ThriftHiveMetastore_get_latest_committed_compaction_info_result(const ThriftHiveMetastore_get_latest_committed_compaction_info_result&); + ThriftHiveMetastore_get_latest_committed_compaction_info_result& operator=(const ThriftHiveMetastore_get_latest_committed_compaction_info_result&); + ThriftHiveMetastore_get_latest_committed_compaction_info_result() noexcept; + + virtual ~ThriftHiveMetastore_get_latest_committed_compaction_info_result() noexcept; + GetLatestCommittedCompactionInfoResponse success; + + _ThriftHiveMetastore_get_latest_committed_compaction_info_result__isset __isset; + + void __set_success(const GetLatestCommittedCompactionInfoResponse& val); + + bool operator == (const ThriftHiveMetastore_get_latest_committed_compaction_info_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_latest_committed_compaction_info_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_latest_committed_compaction_info_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_latest_committed_compaction_info_presult__isset { + _ThriftHiveMetastore_get_latest_committed_compaction_info_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_latest_committed_compaction_info_presult__isset; + +class ThriftHiveMetastore_get_latest_committed_compaction_info_presult { + public: + + + virtual ~ThriftHiveMetastore_get_latest_committed_compaction_info_presult() noexcept; + GetLatestCommittedCompactionInfoResponse* success; + + _ThriftHiveMetastore_get_latest_committed_compaction_info_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_next_notification_args__isset { + _ThriftHiveMetastore_get_next_notification_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_get_next_notification_args__isset; + +class ThriftHiveMetastore_get_next_notification_args { + public: + + ThriftHiveMetastore_get_next_notification_args(const ThriftHiveMetastore_get_next_notification_args&); + ThriftHiveMetastore_get_next_notification_args& operator=(const ThriftHiveMetastore_get_next_notification_args&); + ThriftHiveMetastore_get_next_notification_args() noexcept; + + virtual ~ThriftHiveMetastore_get_next_notification_args() noexcept; + NotificationEventRequest rqst; + + _ThriftHiveMetastore_get_next_notification_args__isset __isset; + + void __set_rqst(const NotificationEventRequest& val); + + bool operator == (const ThriftHiveMetastore_get_next_notification_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_next_notification_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_next_notification_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_next_notification_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_next_notification_pargs() noexcept; + const NotificationEventRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_next_notification_result__isset { + _ThriftHiveMetastore_get_next_notification_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_next_notification_result__isset; + +class ThriftHiveMetastore_get_next_notification_result { + public: + + ThriftHiveMetastore_get_next_notification_result(const ThriftHiveMetastore_get_next_notification_result&); + ThriftHiveMetastore_get_next_notification_result& operator=(const ThriftHiveMetastore_get_next_notification_result&); + ThriftHiveMetastore_get_next_notification_result() noexcept; + + virtual ~ThriftHiveMetastore_get_next_notification_result() noexcept; + NotificationEventResponse success; + + _ThriftHiveMetastore_get_next_notification_result__isset __isset; + + void __set_success(const NotificationEventResponse& val); + + bool operator == (const ThriftHiveMetastore_get_next_notification_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_next_notification_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_next_notification_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_next_notification_presult__isset { + _ThriftHiveMetastore_get_next_notification_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_next_notification_presult__isset; + +class ThriftHiveMetastore_get_next_notification_presult { + public: + + + virtual ~ThriftHiveMetastore_get_next_notification_presult() noexcept; + NotificationEventResponse* success; + + _ThriftHiveMetastore_get_next_notification_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + + +class ThriftHiveMetastore_get_current_notificationEventId_args { + public: + + ThriftHiveMetastore_get_current_notificationEventId_args(const ThriftHiveMetastore_get_current_notificationEventId_args&) noexcept; + ThriftHiveMetastore_get_current_notificationEventId_args& operator=(const ThriftHiveMetastore_get_current_notificationEventId_args&) noexcept; + ThriftHiveMetastore_get_current_notificationEventId_args() noexcept; + + virtual ~ThriftHiveMetastore_get_current_notificationEventId_args() noexcept; + + bool operator == (const ThriftHiveMetastore_get_current_notificationEventId_args & /* rhs */) const; + bool operator != (const ThriftHiveMetastore_get_current_notificationEventId_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_current_notificationEventId_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_current_notificationEventId_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_current_notificationEventId_pargs() noexcept; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_current_notificationEventId_result__isset { + _ThriftHiveMetastore_get_current_notificationEventId_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_current_notificationEventId_result__isset; + +class ThriftHiveMetastore_get_current_notificationEventId_result { + public: + + ThriftHiveMetastore_get_current_notificationEventId_result(const ThriftHiveMetastore_get_current_notificationEventId_result&) noexcept; + ThriftHiveMetastore_get_current_notificationEventId_result& operator=(const ThriftHiveMetastore_get_current_notificationEventId_result&) noexcept; + ThriftHiveMetastore_get_current_notificationEventId_result() noexcept; + + virtual ~ThriftHiveMetastore_get_current_notificationEventId_result() noexcept; + CurrentNotificationEventId success; + + _ThriftHiveMetastore_get_current_notificationEventId_result__isset __isset; + + void __set_success(const CurrentNotificationEventId& val); + + bool operator == (const ThriftHiveMetastore_get_current_notificationEventId_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_current_notificationEventId_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_current_notificationEventId_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_current_notificationEventId_presult__isset { + _ThriftHiveMetastore_get_current_notificationEventId_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_current_notificationEventId_presult__isset; + +class ThriftHiveMetastore_get_current_notificationEventId_presult { + public: + + + virtual ~ThriftHiveMetastore_get_current_notificationEventId_presult() noexcept; + CurrentNotificationEventId* success; + + _ThriftHiveMetastore_get_current_notificationEventId_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_notification_events_count_args__isset { + _ThriftHiveMetastore_get_notification_events_count_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_get_notification_events_count_args__isset; + +class ThriftHiveMetastore_get_notification_events_count_args { + public: + + ThriftHiveMetastore_get_notification_events_count_args(const ThriftHiveMetastore_get_notification_events_count_args&); + ThriftHiveMetastore_get_notification_events_count_args& operator=(const ThriftHiveMetastore_get_notification_events_count_args&); + ThriftHiveMetastore_get_notification_events_count_args() noexcept; + + virtual ~ThriftHiveMetastore_get_notification_events_count_args() noexcept; + NotificationEventsCountRequest rqst; + + _ThriftHiveMetastore_get_notification_events_count_args__isset __isset; + + void __set_rqst(const NotificationEventsCountRequest& val); + + bool operator == (const ThriftHiveMetastore_get_notification_events_count_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_notification_events_count_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_notification_events_count_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_notification_events_count_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_notification_events_count_pargs() noexcept; + const NotificationEventsCountRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_notification_events_count_result__isset { + _ThriftHiveMetastore_get_notification_events_count_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_notification_events_count_result__isset; + +class ThriftHiveMetastore_get_notification_events_count_result { + public: + + ThriftHiveMetastore_get_notification_events_count_result(const ThriftHiveMetastore_get_notification_events_count_result&) noexcept; + ThriftHiveMetastore_get_notification_events_count_result& operator=(const ThriftHiveMetastore_get_notification_events_count_result&) noexcept; + ThriftHiveMetastore_get_notification_events_count_result() noexcept; + + virtual ~ThriftHiveMetastore_get_notification_events_count_result() noexcept; + NotificationEventsCountResponse success; + + _ThriftHiveMetastore_get_notification_events_count_result__isset __isset; + + void __set_success(const NotificationEventsCountResponse& val); + + bool operator == (const ThriftHiveMetastore_get_notification_events_count_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_notification_events_count_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_notification_events_count_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_notification_events_count_presult__isset { + _ThriftHiveMetastore_get_notification_events_count_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_notification_events_count_presult__isset; + +class ThriftHiveMetastore_get_notification_events_count_presult { + public: + + + virtual ~ThriftHiveMetastore_get_notification_events_count_presult() noexcept; + NotificationEventsCountResponse* success; + + _ThriftHiveMetastore_get_notification_events_count_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_fire_listener_event_args__isset { + _ThriftHiveMetastore_fire_listener_event_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_fire_listener_event_args__isset; + +class ThriftHiveMetastore_fire_listener_event_args { + public: + + ThriftHiveMetastore_fire_listener_event_args(const ThriftHiveMetastore_fire_listener_event_args&); + ThriftHiveMetastore_fire_listener_event_args& operator=(const ThriftHiveMetastore_fire_listener_event_args&); + ThriftHiveMetastore_fire_listener_event_args() noexcept; + + virtual ~ThriftHiveMetastore_fire_listener_event_args() noexcept; + FireEventRequest rqst; + + _ThriftHiveMetastore_fire_listener_event_args__isset __isset; + + void __set_rqst(const FireEventRequest& val); + + bool operator == (const ThriftHiveMetastore_fire_listener_event_args & rhs) const; + bool operator != (const ThriftHiveMetastore_fire_listener_event_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_fire_listener_event_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_fire_listener_event_pargs { + public: + + + virtual ~ThriftHiveMetastore_fire_listener_event_pargs() noexcept; + const FireEventRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_fire_listener_event_result__isset { + _ThriftHiveMetastore_fire_listener_event_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_fire_listener_event_result__isset; + +class ThriftHiveMetastore_fire_listener_event_result { + public: + + ThriftHiveMetastore_fire_listener_event_result(const ThriftHiveMetastore_fire_listener_event_result&); + ThriftHiveMetastore_fire_listener_event_result& operator=(const ThriftHiveMetastore_fire_listener_event_result&); + ThriftHiveMetastore_fire_listener_event_result() noexcept; + + virtual ~ThriftHiveMetastore_fire_listener_event_result() noexcept; + FireEventResponse success; + + _ThriftHiveMetastore_fire_listener_event_result__isset __isset; + + void __set_success(const FireEventResponse& val); + + bool operator == (const ThriftHiveMetastore_fire_listener_event_result & rhs) const; + bool operator != (const ThriftHiveMetastore_fire_listener_event_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_fire_listener_event_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_fire_listener_event_presult__isset { + _ThriftHiveMetastore_fire_listener_event_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_fire_listener_event_presult__isset; + +class ThriftHiveMetastore_fire_listener_event_presult { + public: + + + virtual ~ThriftHiveMetastore_fire_listener_event_presult() noexcept; + FireEventResponse* success; + + _ThriftHiveMetastore_fire_listener_event_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + + +class ThriftHiveMetastore_flushCache_args { + public: + + ThriftHiveMetastore_flushCache_args(const ThriftHiveMetastore_flushCache_args&) noexcept; + ThriftHiveMetastore_flushCache_args& operator=(const ThriftHiveMetastore_flushCache_args&) noexcept; + ThriftHiveMetastore_flushCache_args() noexcept; + + virtual ~ThriftHiveMetastore_flushCache_args() noexcept; + + bool operator == (const ThriftHiveMetastore_flushCache_args & /* rhs */) const; + bool operator != (const ThriftHiveMetastore_flushCache_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_flushCache_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_flushCache_pargs { + public: + + + virtual ~ThriftHiveMetastore_flushCache_pargs() noexcept; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_flushCache_result { + public: + + ThriftHiveMetastore_flushCache_result(const ThriftHiveMetastore_flushCache_result&) noexcept; + ThriftHiveMetastore_flushCache_result& operator=(const ThriftHiveMetastore_flushCache_result&) noexcept; + ThriftHiveMetastore_flushCache_result() noexcept; + + virtual ~ThriftHiveMetastore_flushCache_result() noexcept; + + bool operator == (const ThriftHiveMetastore_flushCache_result & /* rhs */) const; + bool operator != (const ThriftHiveMetastore_flushCache_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_flushCache_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_flushCache_presult { + public: + + + virtual ~ThriftHiveMetastore_flushCache_presult() noexcept; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_add_write_notification_log_args__isset { + _ThriftHiveMetastore_add_write_notification_log_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_add_write_notification_log_args__isset; + +class ThriftHiveMetastore_add_write_notification_log_args { + public: + + ThriftHiveMetastore_add_write_notification_log_args(const ThriftHiveMetastore_add_write_notification_log_args&); + ThriftHiveMetastore_add_write_notification_log_args& operator=(const ThriftHiveMetastore_add_write_notification_log_args&); + ThriftHiveMetastore_add_write_notification_log_args() noexcept; + + virtual ~ThriftHiveMetastore_add_write_notification_log_args() noexcept; + WriteNotificationLogRequest rqst; + + _ThriftHiveMetastore_add_write_notification_log_args__isset __isset; + + void __set_rqst(const WriteNotificationLogRequest& val); + + bool operator == (const ThriftHiveMetastore_add_write_notification_log_args & rhs) const; + bool operator != (const ThriftHiveMetastore_add_write_notification_log_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_write_notification_log_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_write_notification_log_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_write_notification_log_pargs() noexcept; + const WriteNotificationLogRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_write_notification_log_result__isset { + _ThriftHiveMetastore_add_write_notification_log_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_add_write_notification_log_result__isset; + +class ThriftHiveMetastore_add_write_notification_log_result { + public: + + ThriftHiveMetastore_add_write_notification_log_result(const ThriftHiveMetastore_add_write_notification_log_result&) noexcept; + ThriftHiveMetastore_add_write_notification_log_result& operator=(const ThriftHiveMetastore_add_write_notification_log_result&) noexcept; + ThriftHiveMetastore_add_write_notification_log_result() noexcept; + + virtual ~ThriftHiveMetastore_add_write_notification_log_result() noexcept; + WriteNotificationLogResponse success; + + _ThriftHiveMetastore_add_write_notification_log_result__isset __isset; + + void __set_success(const WriteNotificationLogResponse& val); + + bool operator == (const ThriftHiveMetastore_add_write_notification_log_result & rhs) const; + bool operator != (const ThriftHiveMetastore_add_write_notification_log_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_write_notification_log_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_write_notification_log_presult__isset { + _ThriftHiveMetastore_add_write_notification_log_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_add_write_notification_log_presult__isset; + +class ThriftHiveMetastore_add_write_notification_log_presult { + public: + + + virtual ~ThriftHiveMetastore_add_write_notification_log_presult() noexcept; + WriteNotificationLogResponse* success; + + _ThriftHiveMetastore_add_write_notification_log_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_add_write_notification_log_in_batch_args__isset { + _ThriftHiveMetastore_add_write_notification_log_in_batch_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_add_write_notification_log_in_batch_args__isset; + +class ThriftHiveMetastore_add_write_notification_log_in_batch_args { + public: + + ThriftHiveMetastore_add_write_notification_log_in_batch_args(const ThriftHiveMetastore_add_write_notification_log_in_batch_args&); + ThriftHiveMetastore_add_write_notification_log_in_batch_args& operator=(const ThriftHiveMetastore_add_write_notification_log_in_batch_args&); + ThriftHiveMetastore_add_write_notification_log_in_batch_args() noexcept; + + virtual ~ThriftHiveMetastore_add_write_notification_log_in_batch_args() noexcept; + WriteNotificationLogBatchRequest rqst; + + _ThriftHiveMetastore_add_write_notification_log_in_batch_args__isset __isset; + + void __set_rqst(const WriteNotificationLogBatchRequest& val); + + bool operator == (const ThriftHiveMetastore_add_write_notification_log_in_batch_args & rhs) const; + bool operator != (const ThriftHiveMetastore_add_write_notification_log_in_batch_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_write_notification_log_in_batch_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_write_notification_log_in_batch_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_write_notification_log_in_batch_pargs() noexcept; + const WriteNotificationLogBatchRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_write_notification_log_in_batch_result__isset { + _ThriftHiveMetastore_add_write_notification_log_in_batch_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_add_write_notification_log_in_batch_result__isset; + +class ThriftHiveMetastore_add_write_notification_log_in_batch_result { + public: + + ThriftHiveMetastore_add_write_notification_log_in_batch_result(const ThriftHiveMetastore_add_write_notification_log_in_batch_result&) noexcept; + ThriftHiveMetastore_add_write_notification_log_in_batch_result& operator=(const ThriftHiveMetastore_add_write_notification_log_in_batch_result&) noexcept; + ThriftHiveMetastore_add_write_notification_log_in_batch_result() noexcept; + + virtual ~ThriftHiveMetastore_add_write_notification_log_in_batch_result() noexcept; + WriteNotificationLogBatchResponse success; + + _ThriftHiveMetastore_add_write_notification_log_in_batch_result__isset __isset; + + void __set_success(const WriteNotificationLogBatchResponse& val); + + bool operator == (const ThriftHiveMetastore_add_write_notification_log_in_batch_result & rhs) const; + bool operator != (const ThriftHiveMetastore_add_write_notification_log_in_batch_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_write_notification_log_in_batch_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_write_notification_log_in_batch_presult__isset { + _ThriftHiveMetastore_add_write_notification_log_in_batch_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_add_write_notification_log_in_batch_presult__isset; + +class ThriftHiveMetastore_add_write_notification_log_in_batch_presult { + public: + + + virtual ~ThriftHiveMetastore_add_write_notification_log_in_batch_presult() noexcept; + WriteNotificationLogBatchResponse* success; + + _ThriftHiveMetastore_add_write_notification_log_in_batch_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_cm_recycle_args__isset { + _ThriftHiveMetastore_cm_recycle_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_cm_recycle_args__isset; + +class ThriftHiveMetastore_cm_recycle_args { + public: + + ThriftHiveMetastore_cm_recycle_args(const ThriftHiveMetastore_cm_recycle_args&); + ThriftHiveMetastore_cm_recycle_args& operator=(const ThriftHiveMetastore_cm_recycle_args&); + ThriftHiveMetastore_cm_recycle_args() noexcept; + + virtual ~ThriftHiveMetastore_cm_recycle_args() noexcept; + CmRecycleRequest request; + + _ThriftHiveMetastore_cm_recycle_args__isset __isset; + + void __set_request(const CmRecycleRequest& val); + + bool operator == (const ThriftHiveMetastore_cm_recycle_args & rhs) const; + bool operator != (const ThriftHiveMetastore_cm_recycle_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_cm_recycle_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_cm_recycle_pargs { + public: + + + virtual ~ThriftHiveMetastore_cm_recycle_pargs() noexcept; + const CmRecycleRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_cm_recycle_result__isset { + _ThriftHiveMetastore_cm_recycle_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_cm_recycle_result__isset; + +class ThriftHiveMetastore_cm_recycle_result { + public: + + ThriftHiveMetastore_cm_recycle_result(const ThriftHiveMetastore_cm_recycle_result&); + ThriftHiveMetastore_cm_recycle_result& operator=(const ThriftHiveMetastore_cm_recycle_result&); + ThriftHiveMetastore_cm_recycle_result() noexcept; + + virtual ~ThriftHiveMetastore_cm_recycle_result() noexcept; + CmRecycleResponse success; + MetaException o1; + + _ThriftHiveMetastore_cm_recycle_result__isset __isset; + + void __set_success(const CmRecycleResponse& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_cm_recycle_result & rhs) const; + bool operator != (const ThriftHiveMetastore_cm_recycle_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_cm_recycle_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_cm_recycle_presult__isset { + _ThriftHiveMetastore_cm_recycle_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_cm_recycle_presult__isset; + +class ThriftHiveMetastore_cm_recycle_presult { + public: + + + virtual ~ThriftHiveMetastore_cm_recycle_presult() noexcept; + CmRecycleResponse* success; + MetaException o1; + + _ThriftHiveMetastore_cm_recycle_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_file_metadata_by_expr_args__isset { + _ThriftHiveMetastore_get_file_metadata_by_expr_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_get_file_metadata_by_expr_args__isset; + +class ThriftHiveMetastore_get_file_metadata_by_expr_args { + public: + + ThriftHiveMetastore_get_file_metadata_by_expr_args(const ThriftHiveMetastore_get_file_metadata_by_expr_args&); + ThriftHiveMetastore_get_file_metadata_by_expr_args& operator=(const ThriftHiveMetastore_get_file_metadata_by_expr_args&); + ThriftHiveMetastore_get_file_metadata_by_expr_args() noexcept; + + virtual ~ThriftHiveMetastore_get_file_metadata_by_expr_args() noexcept; + GetFileMetadataByExprRequest req; + + _ThriftHiveMetastore_get_file_metadata_by_expr_args__isset __isset; + + void __set_req(const GetFileMetadataByExprRequest& val); + + bool operator == (const ThriftHiveMetastore_get_file_metadata_by_expr_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_file_metadata_by_expr_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_file_metadata_by_expr_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_file_metadata_by_expr_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_file_metadata_by_expr_pargs() noexcept; + const GetFileMetadataByExprRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_file_metadata_by_expr_result__isset { + _ThriftHiveMetastore_get_file_metadata_by_expr_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_file_metadata_by_expr_result__isset; + +class ThriftHiveMetastore_get_file_metadata_by_expr_result { + public: + + ThriftHiveMetastore_get_file_metadata_by_expr_result(const ThriftHiveMetastore_get_file_metadata_by_expr_result&); + ThriftHiveMetastore_get_file_metadata_by_expr_result& operator=(const ThriftHiveMetastore_get_file_metadata_by_expr_result&); + ThriftHiveMetastore_get_file_metadata_by_expr_result() noexcept; + + virtual ~ThriftHiveMetastore_get_file_metadata_by_expr_result() noexcept; + GetFileMetadataByExprResult success; + + _ThriftHiveMetastore_get_file_metadata_by_expr_result__isset __isset; + + void __set_success(const GetFileMetadataByExprResult& val); + + bool operator == (const ThriftHiveMetastore_get_file_metadata_by_expr_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_file_metadata_by_expr_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_file_metadata_by_expr_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_file_metadata_by_expr_presult__isset { + _ThriftHiveMetastore_get_file_metadata_by_expr_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_file_metadata_by_expr_presult__isset; + +class ThriftHiveMetastore_get_file_metadata_by_expr_presult { + public: + + + virtual ~ThriftHiveMetastore_get_file_metadata_by_expr_presult() noexcept; + GetFileMetadataByExprResult* success; + + _ThriftHiveMetastore_get_file_metadata_by_expr_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_file_metadata_args__isset { + _ThriftHiveMetastore_get_file_metadata_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_get_file_metadata_args__isset; + +class ThriftHiveMetastore_get_file_metadata_args { + public: + + ThriftHiveMetastore_get_file_metadata_args(const ThriftHiveMetastore_get_file_metadata_args&); + ThriftHiveMetastore_get_file_metadata_args& operator=(const ThriftHiveMetastore_get_file_metadata_args&); + ThriftHiveMetastore_get_file_metadata_args() noexcept; + + virtual ~ThriftHiveMetastore_get_file_metadata_args() noexcept; + GetFileMetadataRequest req; + + _ThriftHiveMetastore_get_file_metadata_args__isset __isset; + + void __set_req(const GetFileMetadataRequest& val); + + bool operator == (const ThriftHiveMetastore_get_file_metadata_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_file_metadata_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_file_metadata_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_file_metadata_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_file_metadata_pargs() noexcept; + const GetFileMetadataRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_file_metadata_result__isset { + _ThriftHiveMetastore_get_file_metadata_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_file_metadata_result__isset; + +class ThriftHiveMetastore_get_file_metadata_result { + public: + + ThriftHiveMetastore_get_file_metadata_result(const ThriftHiveMetastore_get_file_metadata_result&); + ThriftHiveMetastore_get_file_metadata_result& operator=(const ThriftHiveMetastore_get_file_metadata_result&); + ThriftHiveMetastore_get_file_metadata_result() noexcept; + + virtual ~ThriftHiveMetastore_get_file_metadata_result() noexcept; + GetFileMetadataResult success; + + _ThriftHiveMetastore_get_file_metadata_result__isset __isset; + + void __set_success(const GetFileMetadataResult& val); + + bool operator == (const ThriftHiveMetastore_get_file_metadata_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_file_metadata_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_file_metadata_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_file_metadata_presult__isset { + _ThriftHiveMetastore_get_file_metadata_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_file_metadata_presult__isset; + +class ThriftHiveMetastore_get_file_metadata_presult { + public: + + + virtual ~ThriftHiveMetastore_get_file_metadata_presult() noexcept; + GetFileMetadataResult* success; + + _ThriftHiveMetastore_get_file_metadata_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_put_file_metadata_args__isset { + _ThriftHiveMetastore_put_file_metadata_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_put_file_metadata_args__isset; + +class ThriftHiveMetastore_put_file_metadata_args { + public: + + ThriftHiveMetastore_put_file_metadata_args(const ThriftHiveMetastore_put_file_metadata_args&); + ThriftHiveMetastore_put_file_metadata_args& operator=(const ThriftHiveMetastore_put_file_metadata_args&); + ThriftHiveMetastore_put_file_metadata_args() noexcept; + + virtual ~ThriftHiveMetastore_put_file_metadata_args() noexcept; + PutFileMetadataRequest req; + + _ThriftHiveMetastore_put_file_metadata_args__isset __isset; + + void __set_req(const PutFileMetadataRequest& val); + + bool operator == (const ThriftHiveMetastore_put_file_metadata_args & rhs) const; + bool operator != (const ThriftHiveMetastore_put_file_metadata_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_put_file_metadata_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_put_file_metadata_pargs { + public: + + + virtual ~ThriftHiveMetastore_put_file_metadata_pargs() noexcept; + const PutFileMetadataRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_put_file_metadata_result__isset { + _ThriftHiveMetastore_put_file_metadata_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_put_file_metadata_result__isset; + +class ThriftHiveMetastore_put_file_metadata_result { + public: + + ThriftHiveMetastore_put_file_metadata_result(const ThriftHiveMetastore_put_file_metadata_result&) noexcept; + ThriftHiveMetastore_put_file_metadata_result& operator=(const ThriftHiveMetastore_put_file_metadata_result&) noexcept; + ThriftHiveMetastore_put_file_metadata_result() noexcept; + + virtual ~ThriftHiveMetastore_put_file_metadata_result() noexcept; + PutFileMetadataResult success; + + _ThriftHiveMetastore_put_file_metadata_result__isset __isset; + + void __set_success(const PutFileMetadataResult& val); + + bool operator == (const ThriftHiveMetastore_put_file_metadata_result & rhs) const; + bool operator != (const ThriftHiveMetastore_put_file_metadata_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_put_file_metadata_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_put_file_metadata_presult__isset { + _ThriftHiveMetastore_put_file_metadata_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_put_file_metadata_presult__isset; + +class ThriftHiveMetastore_put_file_metadata_presult { + public: + + + virtual ~ThriftHiveMetastore_put_file_metadata_presult() noexcept; + PutFileMetadataResult* success; + + _ThriftHiveMetastore_put_file_metadata_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_clear_file_metadata_args__isset { + _ThriftHiveMetastore_clear_file_metadata_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_clear_file_metadata_args__isset; + +class ThriftHiveMetastore_clear_file_metadata_args { + public: + + ThriftHiveMetastore_clear_file_metadata_args(const ThriftHiveMetastore_clear_file_metadata_args&); + ThriftHiveMetastore_clear_file_metadata_args& operator=(const ThriftHiveMetastore_clear_file_metadata_args&); + ThriftHiveMetastore_clear_file_metadata_args() noexcept; + + virtual ~ThriftHiveMetastore_clear_file_metadata_args() noexcept; + ClearFileMetadataRequest req; + + _ThriftHiveMetastore_clear_file_metadata_args__isset __isset; + + void __set_req(const ClearFileMetadataRequest& val); + + bool operator == (const ThriftHiveMetastore_clear_file_metadata_args & rhs) const; + bool operator != (const ThriftHiveMetastore_clear_file_metadata_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_clear_file_metadata_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_clear_file_metadata_pargs { + public: + + + virtual ~ThriftHiveMetastore_clear_file_metadata_pargs() noexcept; + const ClearFileMetadataRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_clear_file_metadata_result__isset { + _ThriftHiveMetastore_clear_file_metadata_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_clear_file_metadata_result__isset; + +class ThriftHiveMetastore_clear_file_metadata_result { + public: + + ThriftHiveMetastore_clear_file_metadata_result(const ThriftHiveMetastore_clear_file_metadata_result&) noexcept; + ThriftHiveMetastore_clear_file_metadata_result& operator=(const ThriftHiveMetastore_clear_file_metadata_result&) noexcept; + ThriftHiveMetastore_clear_file_metadata_result() noexcept; + + virtual ~ThriftHiveMetastore_clear_file_metadata_result() noexcept; + ClearFileMetadataResult success; + + _ThriftHiveMetastore_clear_file_metadata_result__isset __isset; + + void __set_success(const ClearFileMetadataResult& val); + + bool operator == (const ThriftHiveMetastore_clear_file_metadata_result & rhs) const; + bool operator != (const ThriftHiveMetastore_clear_file_metadata_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_clear_file_metadata_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_clear_file_metadata_presult__isset { + _ThriftHiveMetastore_clear_file_metadata_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_clear_file_metadata_presult__isset; + +class ThriftHiveMetastore_clear_file_metadata_presult { + public: + + + virtual ~ThriftHiveMetastore_clear_file_metadata_presult() noexcept; + ClearFileMetadataResult* success; + + _ThriftHiveMetastore_clear_file_metadata_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_cache_file_metadata_args__isset { + _ThriftHiveMetastore_cache_file_metadata_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_cache_file_metadata_args__isset; + +class ThriftHiveMetastore_cache_file_metadata_args { + public: + + ThriftHiveMetastore_cache_file_metadata_args(const ThriftHiveMetastore_cache_file_metadata_args&); + ThriftHiveMetastore_cache_file_metadata_args& operator=(const ThriftHiveMetastore_cache_file_metadata_args&); + ThriftHiveMetastore_cache_file_metadata_args() noexcept; + + virtual ~ThriftHiveMetastore_cache_file_metadata_args() noexcept; + CacheFileMetadataRequest req; + + _ThriftHiveMetastore_cache_file_metadata_args__isset __isset; + + void __set_req(const CacheFileMetadataRequest& val); + + bool operator == (const ThriftHiveMetastore_cache_file_metadata_args & rhs) const; + bool operator != (const ThriftHiveMetastore_cache_file_metadata_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_cache_file_metadata_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_cache_file_metadata_pargs { + public: + + + virtual ~ThriftHiveMetastore_cache_file_metadata_pargs() noexcept; + const CacheFileMetadataRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_cache_file_metadata_result__isset { + _ThriftHiveMetastore_cache_file_metadata_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_cache_file_metadata_result__isset; + +class ThriftHiveMetastore_cache_file_metadata_result { + public: + + ThriftHiveMetastore_cache_file_metadata_result(const ThriftHiveMetastore_cache_file_metadata_result&) noexcept; + ThriftHiveMetastore_cache_file_metadata_result& operator=(const ThriftHiveMetastore_cache_file_metadata_result&) noexcept; + ThriftHiveMetastore_cache_file_metadata_result() noexcept; + + virtual ~ThriftHiveMetastore_cache_file_metadata_result() noexcept; + CacheFileMetadataResult success; + + _ThriftHiveMetastore_cache_file_metadata_result__isset __isset; + + void __set_success(const CacheFileMetadataResult& val); + + bool operator == (const ThriftHiveMetastore_cache_file_metadata_result & rhs) const; + bool operator != (const ThriftHiveMetastore_cache_file_metadata_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_cache_file_metadata_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_cache_file_metadata_presult__isset { + _ThriftHiveMetastore_cache_file_metadata_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_cache_file_metadata_presult__isset; + +class ThriftHiveMetastore_cache_file_metadata_presult { + public: + + + virtual ~ThriftHiveMetastore_cache_file_metadata_presult() noexcept; + CacheFileMetadataResult* success; + + _ThriftHiveMetastore_cache_file_metadata_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + + +class ThriftHiveMetastore_get_metastore_db_uuid_args { + public: + + ThriftHiveMetastore_get_metastore_db_uuid_args(const ThriftHiveMetastore_get_metastore_db_uuid_args&) noexcept; + ThriftHiveMetastore_get_metastore_db_uuid_args& operator=(const ThriftHiveMetastore_get_metastore_db_uuid_args&) noexcept; + ThriftHiveMetastore_get_metastore_db_uuid_args() noexcept; + + virtual ~ThriftHiveMetastore_get_metastore_db_uuid_args() noexcept; + + bool operator == (const ThriftHiveMetastore_get_metastore_db_uuid_args & /* rhs */) const; + bool operator != (const ThriftHiveMetastore_get_metastore_db_uuid_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_metastore_db_uuid_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_metastore_db_uuid_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_metastore_db_uuid_pargs() noexcept; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_metastore_db_uuid_result__isset { + _ThriftHiveMetastore_get_metastore_db_uuid_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_metastore_db_uuid_result__isset; + +class ThriftHiveMetastore_get_metastore_db_uuid_result { + public: + + ThriftHiveMetastore_get_metastore_db_uuid_result(const ThriftHiveMetastore_get_metastore_db_uuid_result&); + ThriftHiveMetastore_get_metastore_db_uuid_result& operator=(const ThriftHiveMetastore_get_metastore_db_uuid_result&); + ThriftHiveMetastore_get_metastore_db_uuid_result() noexcept; + + virtual ~ThriftHiveMetastore_get_metastore_db_uuid_result() noexcept; + std::string success; + MetaException o1; + + _ThriftHiveMetastore_get_metastore_db_uuid_result__isset __isset; + + void __set_success(const std::string& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_metastore_db_uuid_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_metastore_db_uuid_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_metastore_db_uuid_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_metastore_db_uuid_presult__isset { + _ThriftHiveMetastore_get_metastore_db_uuid_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_metastore_db_uuid_presult__isset; + +class ThriftHiveMetastore_get_metastore_db_uuid_presult { + public: + + + virtual ~ThriftHiveMetastore_get_metastore_db_uuid_presult() noexcept; + std::string* success; + MetaException o1; + + _ThriftHiveMetastore_get_metastore_db_uuid_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_create_resource_plan_args__isset { + _ThriftHiveMetastore_create_resource_plan_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_create_resource_plan_args__isset; + +class ThriftHiveMetastore_create_resource_plan_args { + public: + + ThriftHiveMetastore_create_resource_plan_args(const ThriftHiveMetastore_create_resource_plan_args&); + ThriftHiveMetastore_create_resource_plan_args& operator=(const ThriftHiveMetastore_create_resource_plan_args&); + ThriftHiveMetastore_create_resource_plan_args() noexcept; + + virtual ~ThriftHiveMetastore_create_resource_plan_args() noexcept; + WMCreateResourcePlanRequest request; + + _ThriftHiveMetastore_create_resource_plan_args__isset __isset; + + void __set_request(const WMCreateResourcePlanRequest& val); + + bool operator == (const ThriftHiveMetastore_create_resource_plan_args & rhs) const; + bool operator != (const ThriftHiveMetastore_create_resource_plan_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_resource_plan_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_create_resource_plan_pargs { + public: + + + virtual ~ThriftHiveMetastore_create_resource_plan_pargs() noexcept; + const WMCreateResourcePlanRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_resource_plan_result__isset { + _ThriftHiveMetastore_create_resource_plan_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_create_resource_plan_result__isset; + +class ThriftHiveMetastore_create_resource_plan_result { + public: + + ThriftHiveMetastore_create_resource_plan_result(const ThriftHiveMetastore_create_resource_plan_result&); + ThriftHiveMetastore_create_resource_plan_result& operator=(const ThriftHiveMetastore_create_resource_plan_result&); + ThriftHiveMetastore_create_resource_plan_result() noexcept; + + virtual ~ThriftHiveMetastore_create_resource_plan_result() noexcept; + WMCreateResourcePlanResponse success; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + + _ThriftHiveMetastore_create_resource_plan_result__isset __isset; + + void __set_success(const WMCreateResourcePlanResponse& val); + + void __set_o1(const AlreadyExistsException& val); + + void __set_o2(const InvalidObjectException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_create_resource_plan_result & rhs) const; + bool operator != (const ThriftHiveMetastore_create_resource_plan_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_resource_plan_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_resource_plan_presult__isset { + _ThriftHiveMetastore_create_resource_plan_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_create_resource_plan_presult__isset; + +class ThriftHiveMetastore_create_resource_plan_presult { + public: + + + virtual ~ThriftHiveMetastore_create_resource_plan_presult() noexcept; + WMCreateResourcePlanResponse* success; + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + + _ThriftHiveMetastore_create_resource_plan_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_resource_plan_args__isset { + _ThriftHiveMetastore_get_resource_plan_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_resource_plan_args__isset; + +class ThriftHiveMetastore_get_resource_plan_args { + public: + + ThriftHiveMetastore_get_resource_plan_args(const ThriftHiveMetastore_get_resource_plan_args&); + ThriftHiveMetastore_get_resource_plan_args& operator=(const ThriftHiveMetastore_get_resource_plan_args&); + ThriftHiveMetastore_get_resource_plan_args() noexcept; + + virtual ~ThriftHiveMetastore_get_resource_plan_args() noexcept; + WMGetResourcePlanRequest request; + + _ThriftHiveMetastore_get_resource_plan_args__isset __isset; + + void __set_request(const WMGetResourcePlanRequest& val); + + bool operator == (const ThriftHiveMetastore_get_resource_plan_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_resource_plan_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_resource_plan_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_resource_plan_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_resource_plan_pargs() noexcept; + const WMGetResourcePlanRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_resource_plan_result__isset { + _ThriftHiveMetastore_get_resource_plan_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_resource_plan_result__isset; + +class ThriftHiveMetastore_get_resource_plan_result { + public: + + ThriftHiveMetastore_get_resource_plan_result(const ThriftHiveMetastore_get_resource_plan_result&); + ThriftHiveMetastore_get_resource_plan_result& operator=(const ThriftHiveMetastore_get_resource_plan_result&); + ThriftHiveMetastore_get_resource_plan_result() noexcept; + + virtual ~ThriftHiveMetastore_get_resource_plan_result() noexcept; + WMGetResourcePlanResponse success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_resource_plan_result__isset __isset; + + void __set_success(const WMGetResourcePlanResponse& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_resource_plan_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_resource_plan_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_resource_plan_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_resource_plan_presult__isset { + _ThriftHiveMetastore_get_resource_plan_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_resource_plan_presult__isset; + +class ThriftHiveMetastore_get_resource_plan_presult { + public: + + + virtual ~ThriftHiveMetastore_get_resource_plan_presult() noexcept; + WMGetResourcePlanResponse* success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_resource_plan_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_active_resource_plan_args__isset { + _ThriftHiveMetastore_get_active_resource_plan_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_active_resource_plan_args__isset; + +class ThriftHiveMetastore_get_active_resource_plan_args { + public: + + ThriftHiveMetastore_get_active_resource_plan_args(const ThriftHiveMetastore_get_active_resource_plan_args&); + ThriftHiveMetastore_get_active_resource_plan_args& operator=(const ThriftHiveMetastore_get_active_resource_plan_args&); + ThriftHiveMetastore_get_active_resource_plan_args() noexcept; + + virtual ~ThriftHiveMetastore_get_active_resource_plan_args() noexcept; + WMGetActiveResourcePlanRequest request; + + _ThriftHiveMetastore_get_active_resource_plan_args__isset __isset; + + void __set_request(const WMGetActiveResourcePlanRequest& val); + + bool operator == (const ThriftHiveMetastore_get_active_resource_plan_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_active_resource_plan_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_active_resource_plan_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_active_resource_plan_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_active_resource_plan_pargs() noexcept; + const WMGetActiveResourcePlanRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_active_resource_plan_result__isset { + _ThriftHiveMetastore_get_active_resource_plan_result__isset() : success(false), o2(false) {} + bool success :1; + bool o2 :1; +} _ThriftHiveMetastore_get_active_resource_plan_result__isset; + +class ThriftHiveMetastore_get_active_resource_plan_result { + public: + + ThriftHiveMetastore_get_active_resource_plan_result(const ThriftHiveMetastore_get_active_resource_plan_result&); + ThriftHiveMetastore_get_active_resource_plan_result& operator=(const ThriftHiveMetastore_get_active_resource_plan_result&); + ThriftHiveMetastore_get_active_resource_plan_result() noexcept; + + virtual ~ThriftHiveMetastore_get_active_resource_plan_result() noexcept; + WMGetActiveResourcePlanResponse success; + MetaException o2; + + _ThriftHiveMetastore_get_active_resource_plan_result__isset __isset; + + void __set_success(const WMGetActiveResourcePlanResponse& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_active_resource_plan_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_active_resource_plan_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_active_resource_plan_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_active_resource_plan_presult__isset { + _ThriftHiveMetastore_get_active_resource_plan_presult__isset() : success(false), o2(false) {} + bool success :1; + bool o2 :1; +} _ThriftHiveMetastore_get_active_resource_plan_presult__isset; + +class ThriftHiveMetastore_get_active_resource_plan_presult { + public: + + + virtual ~ThriftHiveMetastore_get_active_resource_plan_presult() noexcept; + WMGetActiveResourcePlanResponse* success; + MetaException o2; + + _ThriftHiveMetastore_get_active_resource_plan_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_all_resource_plans_args__isset { + _ThriftHiveMetastore_get_all_resource_plans_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_all_resource_plans_args__isset; + +class ThriftHiveMetastore_get_all_resource_plans_args { + public: + + ThriftHiveMetastore_get_all_resource_plans_args(const ThriftHiveMetastore_get_all_resource_plans_args&); + ThriftHiveMetastore_get_all_resource_plans_args& operator=(const ThriftHiveMetastore_get_all_resource_plans_args&); + ThriftHiveMetastore_get_all_resource_plans_args() noexcept; + + virtual ~ThriftHiveMetastore_get_all_resource_plans_args() noexcept; + WMGetAllResourcePlanRequest request; + + _ThriftHiveMetastore_get_all_resource_plans_args__isset __isset; + + void __set_request(const WMGetAllResourcePlanRequest& val); + + bool operator == (const ThriftHiveMetastore_get_all_resource_plans_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_all_resource_plans_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_all_resource_plans_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_all_resource_plans_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_all_resource_plans_pargs() noexcept; + const WMGetAllResourcePlanRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_all_resource_plans_result__isset { + _ThriftHiveMetastore_get_all_resource_plans_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_all_resource_plans_result__isset; + +class ThriftHiveMetastore_get_all_resource_plans_result { + public: + + ThriftHiveMetastore_get_all_resource_plans_result(const ThriftHiveMetastore_get_all_resource_plans_result&); + ThriftHiveMetastore_get_all_resource_plans_result& operator=(const ThriftHiveMetastore_get_all_resource_plans_result&); + ThriftHiveMetastore_get_all_resource_plans_result() noexcept; + + virtual ~ThriftHiveMetastore_get_all_resource_plans_result() noexcept; + WMGetAllResourcePlanResponse success; + MetaException o1; + + _ThriftHiveMetastore_get_all_resource_plans_result__isset __isset; + + void __set_success(const WMGetAllResourcePlanResponse& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_all_resource_plans_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_all_resource_plans_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_all_resource_plans_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_all_resource_plans_presult__isset { + _ThriftHiveMetastore_get_all_resource_plans_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_all_resource_plans_presult__isset; + +class ThriftHiveMetastore_get_all_resource_plans_presult { + public: + + + virtual ~ThriftHiveMetastore_get_all_resource_plans_presult() noexcept; + WMGetAllResourcePlanResponse* success; + MetaException o1; + + _ThriftHiveMetastore_get_all_resource_plans_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_alter_resource_plan_args__isset { + _ThriftHiveMetastore_alter_resource_plan_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_alter_resource_plan_args__isset; + +class ThriftHiveMetastore_alter_resource_plan_args { + public: + + ThriftHiveMetastore_alter_resource_plan_args(const ThriftHiveMetastore_alter_resource_plan_args&); + ThriftHiveMetastore_alter_resource_plan_args& operator=(const ThriftHiveMetastore_alter_resource_plan_args&); + ThriftHiveMetastore_alter_resource_plan_args() noexcept; + + virtual ~ThriftHiveMetastore_alter_resource_plan_args() noexcept; + WMAlterResourcePlanRequest request; + + _ThriftHiveMetastore_alter_resource_plan_args__isset __isset; + + void __set_request(const WMAlterResourcePlanRequest& val); + + bool operator == (const ThriftHiveMetastore_alter_resource_plan_args & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_resource_plan_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_resource_plan_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_alter_resource_plan_pargs { + public: + + + virtual ~ThriftHiveMetastore_alter_resource_plan_pargs() noexcept; + const WMAlterResourcePlanRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_resource_plan_result__isset { + _ThriftHiveMetastore_alter_resource_plan_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_alter_resource_plan_result__isset; + +class ThriftHiveMetastore_alter_resource_plan_result { + public: + + ThriftHiveMetastore_alter_resource_plan_result(const ThriftHiveMetastore_alter_resource_plan_result&); + ThriftHiveMetastore_alter_resource_plan_result& operator=(const ThriftHiveMetastore_alter_resource_plan_result&); + ThriftHiveMetastore_alter_resource_plan_result() noexcept; + + virtual ~ThriftHiveMetastore_alter_resource_plan_result() noexcept; + WMAlterResourcePlanResponse success; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_alter_resource_plan_result__isset __isset; + + void __set_success(const WMAlterResourcePlanResponse& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const InvalidOperationException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_alter_resource_plan_result & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_resource_plan_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_resource_plan_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_resource_plan_presult__isset { + _ThriftHiveMetastore_alter_resource_plan_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_alter_resource_plan_presult__isset; + +class ThriftHiveMetastore_alter_resource_plan_presult { + public: + + + virtual ~ThriftHiveMetastore_alter_resource_plan_presult() noexcept; + WMAlterResourcePlanResponse* success; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_alter_resource_plan_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_validate_resource_plan_args__isset { + _ThriftHiveMetastore_validate_resource_plan_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_validate_resource_plan_args__isset; + +class ThriftHiveMetastore_validate_resource_plan_args { + public: + + ThriftHiveMetastore_validate_resource_plan_args(const ThriftHiveMetastore_validate_resource_plan_args&); + ThriftHiveMetastore_validate_resource_plan_args& operator=(const ThriftHiveMetastore_validate_resource_plan_args&); + ThriftHiveMetastore_validate_resource_plan_args() noexcept; + + virtual ~ThriftHiveMetastore_validate_resource_plan_args() noexcept; + WMValidateResourcePlanRequest request; + + _ThriftHiveMetastore_validate_resource_plan_args__isset __isset; + + void __set_request(const WMValidateResourcePlanRequest& val); + + bool operator == (const ThriftHiveMetastore_validate_resource_plan_args & rhs) const; + bool operator != (const ThriftHiveMetastore_validate_resource_plan_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_validate_resource_plan_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_validate_resource_plan_pargs { + public: + + + virtual ~ThriftHiveMetastore_validate_resource_plan_pargs() noexcept; + const WMValidateResourcePlanRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_validate_resource_plan_result__isset { + _ThriftHiveMetastore_validate_resource_plan_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_validate_resource_plan_result__isset; + +class ThriftHiveMetastore_validate_resource_plan_result { + public: + + ThriftHiveMetastore_validate_resource_plan_result(const ThriftHiveMetastore_validate_resource_plan_result&); + ThriftHiveMetastore_validate_resource_plan_result& operator=(const ThriftHiveMetastore_validate_resource_plan_result&); + ThriftHiveMetastore_validate_resource_plan_result() noexcept; + + virtual ~ThriftHiveMetastore_validate_resource_plan_result() noexcept; + WMValidateResourcePlanResponse success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_validate_resource_plan_result__isset __isset; + + void __set_success(const WMValidateResourcePlanResponse& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_validate_resource_plan_result & rhs) const; + bool operator != (const ThriftHiveMetastore_validate_resource_plan_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_validate_resource_plan_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_validate_resource_plan_presult__isset { + _ThriftHiveMetastore_validate_resource_plan_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_validate_resource_plan_presult__isset; + +class ThriftHiveMetastore_validate_resource_plan_presult { + public: + + + virtual ~ThriftHiveMetastore_validate_resource_plan_presult() noexcept; + WMValidateResourcePlanResponse* success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_validate_resource_plan_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_resource_plan_args__isset { + _ThriftHiveMetastore_drop_resource_plan_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_drop_resource_plan_args__isset; + +class ThriftHiveMetastore_drop_resource_plan_args { + public: + + ThriftHiveMetastore_drop_resource_plan_args(const ThriftHiveMetastore_drop_resource_plan_args&); + ThriftHiveMetastore_drop_resource_plan_args& operator=(const ThriftHiveMetastore_drop_resource_plan_args&); + ThriftHiveMetastore_drop_resource_plan_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_resource_plan_args() noexcept; + WMDropResourcePlanRequest request; + + _ThriftHiveMetastore_drop_resource_plan_args__isset __isset; + + void __set_request(const WMDropResourcePlanRequest& val); + + bool operator == (const ThriftHiveMetastore_drop_resource_plan_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_resource_plan_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_resource_plan_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_resource_plan_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_resource_plan_pargs() noexcept; + const WMDropResourcePlanRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_resource_plan_result__isset { + _ThriftHiveMetastore_drop_resource_plan_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_resource_plan_result__isset; + +class ThriftHiveMetastore_drop_resource_plan_result { + public: + + ThriftHiveMetastore_drop_resource_plan_result(const ThriftHiveMetastore_drop_resource_plan_result&); + ThriftHiveMetastore_drop_resource_plan_result& operator=(const ThriftHiveMetastore_drop_resource_plan_result&); + ThriftHiveMetastore_drop_resource_plan_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_resource_plan_result() noexcept; + WMDropResourcePlanResponse success; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_resource_plan_result__isset __isset; + + void __set_success(const WMDropResourcePlanResponse& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const InvalidOperationException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_resource_plan_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_resource_plan_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_resource_plan_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_resource_plan_presult__isset { + _ThriftHiveMetastore_drop_resource_plan_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_resource_plan_presult__isset; + +class ThriftHiveMetastore_drop_resource_plan_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_resource_plan_presult() noexcept; + WMDropResourcePlanResponse* success; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_resource_plan_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_create_wm_trigger_args__isset { + _ThriftHiveMetastore_create_wm_trigger_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_create_wm_trigger_args__isset; + +class ThriftHiveMetastore_create_wm_trigger_args { + public: + + ThriftHiveMetastore_create_wm_trigger_args(const ThriftHiveMetastore_create_wm_trigger_args&); + ThriftHiveMetastore_create_wm_trigger_args& operator=(const ThriftHiveMetastore_create_wm_trigger_args&); + ThriftHiveMetastore_create_wm_trigger_args() noexcept; + + virtual ~ThriftHiveMetastore_create_wm_trigger_args() noexcept; + WMCreateTriggerRequest request; + + _ThriftHiveMetastore_create_wm_trigger_args__isset __isset; + + void __set_request(const WMCreateTriggerRequest& val); + + bool operator == (const ThriftHiveMetastore_create_wm_trigger_args & rhs) const; + bool operator != (const ThriftHiveMetastore_create_wm_trigger_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_wm_trigger_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_create_wm_trigger_pargs { + public: + + + virtual ~ThriftHiveMetastore_create_wm_trigger_pargs() noexcept; + const WMCreateTriggerRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_wm_trigger_result__isset { + _ThriftHiveMetastore_create_wm_trigger_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_create_wm_trigger_result__isset; + +class ThriftHiveMetastore_create_wm_trigger_result { + public: + + ThriftHiveMetastore_create_wm_trigger_result(const ThriftHiveMetastore_create_wm_trigger_result&); + ThriftHiveMetastore_create_wm_trigger_result& operator=(const ThriftHiveMetastore_create_wm_trigger_result&); + ThriftHiveMetastore_create_wm_trigger_result() noexcept; + + virtual ~ThriftHiveMetastore_create_wm_trigger_result() noexcept; + WMCreateTriggerResponse success; + AlreadyExistsException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + MetaException o4; + + _ThriftHiveMetastore_create_wm_trigger_result__isset __isset; + + void __set_success(const WMCreateTriggerResponse& val); + + void __set_o1(const AlreadyExistsException& val); + + void __set_o2(const NoSuchObjectException& val); + + void __set_o3(const InvalidObjectException& val); + + void __set_o4(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_create_wm_trigger_result & rhs) const; + bool operator != (const ThriftHiveMetastore_create_wm_trigger_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_wm_trigger_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_wm_trigger_presult__isset { + _ThriftHiveMetastore_create_wm_trigger_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_create_wm_trigger_presult__isset; + +class ThriftHiveMetastore_create_wm_trigger_presult { + public: + + + virtual ~ThriftHiveMetastore_create_wm_trigger_presult() noexcept; + WMCreateTriggerResponse* success; + AlreadyExistsException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + MetaException o4; + + _ThriftHiveMetastore_create_wm_trigger_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_alter_wm_trigger_args__isset { + _ThriftHiveMetastore_alter_wm_trigger_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_alter_wm_trigger_args__isset; + +class ThriftHiveMetastore_alter_wm_trigger_args { + public: + + ThriftHiveMetastore_alter_wm_trigger_args(const ThriftHiveMetastore_alter_wm_trigger_args&); + ThriftHiveMetastore_alter_wm_trigger_args& operator=(const ThriftHiveMetastore_alter_wm_trigger_args&); + ThriftHiveMetastore_alter_wm_trigger_args() noexcept; + + virtual ~ThriftHiveMetastore_alter_wm_trigger_args() noexcept; + WMAlterTriggerRequest request; + + _ThriftHiveMetastore_alter_wm_trigger_args__isset __isset; + + void __set_request(const WMAlterTriggerRequest& val); + + bool operator == (const ThriftHiveMetastore_alter_wm_trigger_args & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_wm_trigger_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_wm_trigger_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_alter_wm_trigger_pargs { + public: + + + virtual ~ThriftHiveMetastore_alter_wm_trigger_pargs() noexcept; + const WMAlterTriggerRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_wm_trigger_result__isset { + _ThriftHiveMetastore_alter_wm_trigger_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_alter_wm_trigger_result__isset; + +class ThriftHiveMetastore_alter_wm_trigger_result { + public: + + ThriftHiveMetastore_alter_wm_trigger_result(const ThriftHiveMetastore_alter_wm_trigger_result&); + ThriftHiveMetastore_alter_wm_trigger_result& operator=(const ThriftHiveMetastore_alter_wm_trigger_result&); + ThriftHiveMetastore_alter_wm_trigger_result() noexcept; + + virtual ~ThriftHiveMetastore_alter_wm_trigger_result() noexcept; + WMAlterTriggerResponse success; + NoSuchObjectException o1; + InvalidObjectException o2; + MetaException o3; + + _ThriftHiveMetastore_alter_wm_trigger_result__isset __isset; + + void __set_success(const WMAlterTriggerResponse& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const InvalidObjectException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_alter_wm_trigger_result & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_wm_trigger_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_wm_trigger_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_wm_trigger_presult__isset { + _ThriftHiveMetastore_alter_wm_trigger_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_alter_wm_trigger_presult__isset; + +class ThriftHiveMetastore_alter_wm_trigger_presult { + public: + + + virtual ~ThriftHiveMetastore_alter_wm_trigger_presult() noexcept; + WMAlterTriggerResponse* success; + NoSuchObjectException o1; + InvalidObjectException o2; + MetaException o3; + + _ThriftHiveMetastore_alter_wm_trigger_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_wm_trigger_args__isset { + _ThriftHiveMetastore_drop_wm_trigger_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_drop_wm_trigger_args__isset; + +class ThriftHiveMetastore_drop_wm_trigger_args { + public: + + ThriftHiveMetastore_drop_wm_trigger_args(const ThriftHiveMetastore_drop_wm_trigger_args&); + ThriftHiveMetastore_drop_wm_trigger_args& operator=(const ThriftHiveMetastore_drop_wm_trigger_args&); + ThriftHiveMetastore_drop_wm_trigger_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_wm_trigger_args() noexcept; + WMDropTriggerRequest request; + + _ThriftHiveMetastore_drop_wm_trigger_args__isset __isset; + + void __set_request(const WMDropTriggerRequest& val); + + bool operator == (const ThriftHiveMetastore_drop_wm_trigger_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_wm_trigger_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_wm_trigger_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_wm_trigger_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_wm_trigger_pargs() noexcept; + const WMDropTriggerRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_wm_trigger_result__isset { + _ThriftHiveMetastore_drop_wm_trigger_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_wm_trigger_result__isset; + +class ThriftHiveMetastore_drop_wm_trigger_result { + public: + + ThriftHiveMetastore_drop_wm_trigger_result(const ThriftHiveMetastore_drop_wm_trigger_result&); + ThriftHiveMetastore_drop_wm_trigger_result& operator=(const ThriftHiveMetastore_drop_wm_trigger_result&); + ThriftHiveMetastore_drop_wm_trigger_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_wm_trigger_result() noexcept; + WMDropTriggerResponse success; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_wm_trigger_result__isset __isset; + + void __set_success(const WMDropTriggerResponse& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const InvalidOperationException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_wm_trigger_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_wm_trigger_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_wm_trigger_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_wm_trigger_presult__isset { + _ThriftHiveMetastore_drop_wm_trigger_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_wm_trigger_presult__isset; + +class ThriftHiveMetastore_drop_wm_trigger_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_wm_trigger_presult() noexcept; + WMDropTriggerResponse* success; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_wm_trigger_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_triggers_for_resourceplan_args__isset { + _ThriftHiveMetastore_get_triggers_for_resourceplan_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_triggers_for_resourceplan_args__isset; + +class ThriftHiveMetastore_get_triggers_for_resourceplan_args { + public: + + ThriftHiveMetastore_get_triggers_for_resourceplan_args(const ThriftHiveMetastore_get_triggers_for_resourceplan_args&); + ThriftHiveMetastore_get_triggers_for_resourceplan_args& operator=(const ThriftHiveMetastore_get_triggers_for_resourceplan_args&); + ThriftHiveMetastore_get_triggers_for_resourceplan_args() noexcept; + + virtual ~ThriftHiveMetastore_get_triggers_for_resourceplan_args() noexcept; + WMGetTriggersForResourePlanRequest request; + + _ThriftHiveMetastore_get_triggers_for_resourceplan_args__isset __isset; + + void __set_request(const WMGetTriggersForResourePlanRequest& val); + + bool operator == (const ThriftHiveMetastore_get_triggers_for_resourceplan_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_triggers_for_resourceplan_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_triggers_for_resourceplan_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_triggers_for_resourceplan_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_triggers_for_resourceplan_pargs() noexcept; + const WMGetTriggersForResourePlanRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_triggers_for_resourceplan_result__isset { + _ThriftHiveMetastore_get_triggers_for_resourceplan_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_triggers_for_resourceplan_result__isset; + +class ThriftHiveMetastore_get_triggers_for_resourceplan_result { + public: + + ThriftHiveMetastore_get_triggers_for_resourceplan_result(const ThriftHiveMetastore_get_triggers_for_resourceplan_result&); + ThriftHiveMetastore_get_triggers_for_resourceplan_result& operator=(const ThriftHiveMetastore_get_triggers_for_resourceplan_result&); + ThriftHiveMetastore_get_triggers_for_resourceplan_result() noexcept; + + virtual ~ThriftHiveMetastore_get_triggers_for_resourceplan_result() noexcept; + WMGetTriggersForResourePlanResponse success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_triggers_for_resourceplan_result__isset __isset; + + void __set_success(const WMGetTriggersForResourePlanResponse& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_triggers_for_resourceplan_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_triggers_for_resourceplan_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_triggers_for_resourceplan_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_triggers_for_resourceplan_presult__isset { + _ThriftHiveMetastore_get_triggers_for_resourceplan_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_triggers_for_resourceplan_presult__isset; + +class ThriftHiveMetastore_get_triggers_for_resourceplan_presult { + public: + + + virtual ~ThriftHiveMetastore_get_triggers_for_resourceplan_presult() noexcept; + WMGetTriggersForResourePlanResponse* success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_triggers_for_resourceplan_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_create_wm_pool_args__isset { + _ThriftHiveMetastore_create_wm_pool_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_create_wm_pool_args__isset; + +class ThriftHiveMetastore_create_wm_pool_args { + public: + + ThriftHiveMetastore_create_wm_pool_args(const ThriftHiveMetastore_create_wm_pool_args&); + ThriftHiveMetastore_create_wm_pool_args& operator=(const ThriftHiveMetastore_create_wm_pool_args&); + ThriftHiveMetastore_create_wm_pool_args() noexcept; + + virtual ~ThriftHiveMetastore_create_wm_pool_args() noexcept; + WMCreatePoolRequest request; + + _ThriftHiveMetastore_create_wm_pool_args__isset __isset; + + void __set_request(const WMCreatePoolRequest& val); + + bool operator == (const ThriftHiveMetastore_create_wm_pool_args & rhs) const; + bool operator != (const ThriftHiveMetastore_create_wm_pool_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_wm_pool_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_create_wm_pool_pargs { + public: + + + virtual ~ThriftHiveMetastore_create_wm_pool_pargs() noexcept; + const WMCreatePoolRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_wm_pool_result__isset { + _ThriftHiveMetastore_create_wm_pool_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_create_wm_pool_result__isset; + +class ThriftHiveMetastore_create_wm_pool_result { + public: + + ThriftHiveMetastore_create_wm_pool_result(const ThriftHiveMetastore_create_wm_pool_result&); + ThriftHiveMetastore_create_wm_pool_result& operator=(const ThriftHiveMetastore_create_wm_pool_result&); + ThriftHiveMetastore_create_wm_pool_result() noexcept; + + virtual ~ThriftHiveMetastore_create_wm_pool_result() noexcept; + WMCreatePoolResponse success; + AlreadyExistsException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + MetaException o4; + + _ThriftHiveMetastore_create_wm_pool_result__isset __isset; + + void __set_success(const WMCreatePoolResponse& val); + + void __set_o1(const AlreadyExistsException& val); + + void __set_o2(const NoSuchObjectException& val); + + void __set_o3(const InvalidObjectException& val); + + void __set_o4(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_create_wm_pool_result & rhs) const; + bool operator != (const ThriftHiveMetastore_create_wm_pool_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_wm_pool_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_wm_pool_presult__isset { + _ThriftHiveMetastore_create_wm_pool_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_create_wm_pool_presult__isset; + +class ThriftHiveMetastore_create_wm_pool_presult { + public: + + + virtual ~ThriftHiveMetastore_create_wm_pool_presult() noexcept; + WMCreatePoolResponse* success; + AlreadyExistsException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + MetaException o4; + + _ThriftHiveMetastore_create_wm_pool_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_alter_wm_pool_args__isset { + _ThriftHiveMetastore_alter_wm_pool_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_alter_wm_pool_args__isset; + +class ThriftHiveMetastore_alter_wm_pool_args { + public: + + ThriftHiveMetastore_alter_wm_pool_args(const ThriftHiveMetastore_alter_wm_pool_args&); + ThriftHiveMetastore_alter_wm_pool_args& operator=(const ThriftHiveMetastore_alter_wm_pool_args&); + ThriftHiveMetastore_alter_wm_pool_args() noexcept; + + virtual ~ThriftHiveMetastore_alter_wm_pool_args() noexcept; + WMAlterPoolRequest request; + + _ThriftHiveMetastore_alter_wm_pool_args__isset __isset; + + void __set_request(const WMAlterPoolRequest& val); + + bool operator == (const ThriftHiveMetastore_alter_wm_pool_args & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_wm_pool_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_wm_pool_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_alter_wm_pool_pargs { + public: + + + virtual ~ThriftHiveMetastore_alter_wm_pool_pargs() noexcept; + const WMAlterPoolRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_wm_pool_result__isset { + _ThriftHiveMetastore_alter_wm_pool_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_alter_wm_pool_result__isset; + +class ThriftHiveMetastore_alter_wm_pool_result { + public: + + ThriftHiveMetastore_alter_wm_pool_result(const ThriftHiveMetastore_alter_wm_pool_result&); + ThriftHiveMetastore_alter_wm_pool_result& operator=(const ThriftHiveMetastore_alter_wm_pool_result&); + ThriftHiveMetastore_alter_wm_pool_result() noexcept; + + virtual ~ThriftHiveMetastore_alter_wm_pool_result() noexcept; + WMAlterPoolResponse success; + AlreadyExistsException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + MetaException o4; + + _ThriftHiveMetastore_alter_wm_pool_result__isset __isset; + + void __set_success(const WMAlterPoolResponse& val); + + void __set_o1(const AlreadyExistsException& val); + + void __set_o2(const NoSuchObjectException& val); + + void __set_o3(const InvalidObjectException& val); + + void __set_o4(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_alter_wm_pool_result & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_wm_pool_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_wm_pool_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_wm_pool_presult__isset { + _ThriftHiveMetastore_alter_wm_pool_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_alter_wm_pool_presult__isset; + +class ThriftHiveMetastore_alter_wm_pool_presult { + public: + + + virtual ~ThriftHiveMetastore_alter_wm_pool_presult() noexcept; + WMAlterPoolResponse* success; + AlreadyExistsException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + MetaException o4; + + _ThriftHiveMetastore_alter_wm_pool_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_wm_pool_args__isset { + _ThriftHiveMetastore_drop_wm_pool_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_drop_wm_pool_args__isset; + +class ThriftHiveMetastore_drop_wm_pool_args { + public: + + ThriftHiveMetastore_drop_wm_pool_args(const ThriftHiveMetastore_drop_wm_pool_args&); + ThriftHiveMetastore_drop_wm_pool_args& operator=(const ThriftHiveMetastore_drop_wm_pool_args&); + ThriftHiveMetastore_drop_wm_pool_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_wm_pool_args() noexcept; + WMDropPoolRequest request; + + _ThriftHiveMetastore_drop_wm_pool_args__isset __isset; + + void __set_request(const WMDropPoolRequest& val); + + bool operator == (const ThriftHiveMetastore_drop_wm_pool_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_wm_pool_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_wm_pool_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_wm_pool_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_wm_pool_pargs() noexcept; + const WMDropPoolRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_wm_pool_result__isset { + _ThriftHiveMetastore_drop_wm_pool_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_wm_pool_result__isset; + +class ThriftHiveMetastore_drop_wm_pool_result { + public: + + ThriftHiveMetastore_drop_wm_pool_result(const ThriftHiveMetastore_drop_wm_pool_result&); + ThriftHiveMetastore_drop_wm_pool_result& operator=(const ThriftHiveMetastore_drop_wm_pool_result&); + ThriftHiveMetastore_drop_wm_pool_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_wm_pool_result() noexcept; + WMDropPoolResponse success; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_wm_pool_result__isset __isset; + + void __set_success(const WMDropPoolResponse& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const InvalidOperationException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_wm_pool_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_wm_pool_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_wm_pool_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_wm_pool_presult__isset { + _ThriftHiveMetastore_drop_wm_pool_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_wm_pool_presult__isset; + +class ThriftHiveMetastore_drop_wm_pool_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_wm_pool_presult() noexcept; + WMDropPoolResponse* success; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_wm_pool_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_create_or_update_wm_mapping_args__isset { + _ThriftHiveMetastore_create_or_update_wm_mapping_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_create_or_update_wm_mapping_args__isset; + +class ThriftHiveMetastore_create_or_update_wm_mapping_args { + public: + + ThriftHiveMetastore_create_or_update_wm_mapping_args(const ThriftHiveMetastore_create_or_update_wm_mapping_args&); + ThriftHiveMetastore_create_or_update_wm_mapping_args& operator=(const ThriftHiveMetastore_create_or_update_wm_mapping_args&); + ThriftHiveMetastore_create_or_update_wm_mapping_args() noexcept; + + virtual ~ThriftHiveMetastore_create_or_update_wm_mapping_args() noexcept; + WMCreateOrUpdateMappingRequest request; + + _ThriftHiveMetastore_create_or_update_wm_mapping_args__isset __isset; + + void __set_request(const WMCreateOrUpdateMappingRequest& val); + + bool operator == (const ThriftHiveMetastore_create_or_update_wm_mapping_args & rhs) const; + bool operator != (const ThriftHiveMetastore_create_or_update_wm_mapping_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_or_update_wm_mapping_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_create_or_update_wm_mapping_pargs { + public: + + + virtual ~ThriftHiveMetastore_create_or_update_wm_mapping_pargs() noexcept; + const WMCreateOrUpdateMappingRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_or_update_wm_mapping_result__isset { + _ThriftHiveMetastore_create_or_update_wm_mapping_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_create_or_update_wm_mapping_result__isset; + +class ThriftHiveMetastore_create_or_update_wm_mapping_result { + public: + + ThriftHiveMetastore_create_or_update_wm_mapping_result(const ThriftHiveMetastore_create_or_update_wm_mapping_result&); + ThriftHiveMetastore_create_or_update_wm_mapping_result& operator=(const ThriftHiveMetastore_create_or_update_wm_mapping_result&); + ThriftHiveMetastore_create_or_update_wm_mapping_result() noexcept; + + virtual ~ThriftHiveMetastore_create_or_update_wm_mapping_result() noexcept; + WMCreateOrUpdateMappingResponse success; + AlreadyExistsException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + MetaException o4; + + _ThriftHiveMetastore_create_or_update_wm_mapping_result__isset __isset; + + void __set_success(const WMCreateOrUpdateMappingResponse& val); + + void __set_o1(const AlreadyExistsException& val); + + void __set_o2(const NoSuchObjectException& val); + + void __set_o3(const InvalidObjectException& val); + + void __set_o4(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_create_or_update_wm_mapping_result & rhs) const; + bool operator != (const ThriftHiveMetastore_create_or_update_wm_mapping_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_or_update_wm_mapping_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_or_update_wm_mapping_presult__isset { + _ThriftHiveMetastore_create_or_update_wm_mapping_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_create_or_update_wm_mapping_presult__isset; + +class ThriftHiveMetastore_create_or_update_wm_mapping_presult { + public: + + + virtual ~ThriftHiveMetastore_create_or_update_wm_mapping_presult() noexcept; + WMCreateOrUpdateMappingResponse* success; + AlreadyExistsException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + MetaException o4; + + _ThriftHiveMetastore_create_or_update_wm_mapping_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_wm_mapping_args__isset { + _ThriftHiveMetastore_drop_wm_mapping_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_drop_wm_mapping_args__isset; + +class ThriftHiveMetastore_drop_wm_mapping_args { + public: + + ThriftHiveMetastore_drop_wm_mapping_args(const ThriftHiveMetastore_drop_wm_mapping_args&); + ThriftHiveMetastore_drop_wm_mapping_args& operator=(const ThriftHiveMetastore_drop_wm_mapping_args&); + ThriftHiveMetastore_drop_wm_mapping_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_wm_mapping_args() noexcept; + WMDropMappingRequest request; + + _ThriftHiveMetastore_drop_wm_mapping_args__isset __isset; + + void __set_request(const WMDropMappingRequest& val); + + bool operator == (const ThriftHiveMetastore_drop_wm_mapping_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_wm_mapping_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_wm_mapping_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_wm_mapping_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_wm_mapping_pargs() noexcept; + const WMDropMappingRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_wm_mapping_result__isset { + _ThriftHiveMetastore_drop_wm_mapping_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_wm_mapping_result__isset; + +class ThriftHiveMetastore_drop_wm_mapping_result { + public: + + ThriftHiveMetastore_drop_wm_mapping_result(const ThriftHiveMetastore_drop_wm_mapping_result&); + ThriftHiveMetastore_drop_wm_mapping_result& operator=(const ThriftHiveMetastore_drop_wm_mapping_result&); + ThriftHiveMetastore_drop_wm_mapping_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_wm_mapping_result() noexcept; + WMDropMappingResponse success; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_wm_mapping_result__isset __isset; + + void __set_success(const WMDropMappingResponse& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const InvalidOperationException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_wm_mapping_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_wm_mapping_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_wm_mapping_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_wm_mapping_presult__isset { + _ThriftHiveMetastore_drop_wm_mapping_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_wm_mapping_presult__isset; + +class ThriftHiveMetastore_drop_wm_mapping_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_wm_mapping_presult() noexcept; + WMDropMappingResponse* success; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_wm_mapping_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args__isset { + _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args__isset; + +class ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args { + public: + + ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args(const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args&); + ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args& operator=(const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args&); + ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args() noexcept; + + virtual ~ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args() noexcept; + WMCreateOrDropTriggerToPoolMappingRequest request; + + _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args__isset __isset; + + void __set_request(const WMCreateOrDropTriggerToPoolMappingRequest& val); + + bool operator == (const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args & rhs) const; + bool operator != (const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_pargs { + public: + + + virtual ~ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_pargs() noexcept; + const WMCreateOrDropTriggerToPoolMappingRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result__isset { + _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result__isset; + +class ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result { + public: + + ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result(const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result&); + ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result& operator=(const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result&); + ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result() noexcept; + + virtual ~ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result() noexcept; + WMCreateOrDropTriggerToPoolMappingResponse success; + AlreadyExistsException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + MetaException o4; + + _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result__isset __isset; + + void __set_success(const WMCreateOrDropTriggerToPoolMappingResponse& val); + + void __set_o1(const AlreadyExistsException& val); + + void __set_o2(const NoSuchObjectException& val); + + void __set_o3(const InvalidObjectException& val); + + void __set_o4(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result & rhs) const; + bool operator != (const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_presult__isset { + _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_presult__isset; + +class ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_presult { + public: + + + virtual ~ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_presult() noexcept; + WMCreateOrDropTriggerToPoolMappingResponse* success; + AlreadyExistsException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + MetaException o4; + + _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_create_ischema_args__isset { + _ThriftHiveMetastore_create_ischema_args__isset() : schema(false) {} + bool schema :1; +} _ThriftHiveMetastore_create_ischema_args__isset; + +class ThriftHiveMetastore_create_ischema_args { + public: + + ThriftHiveMetastore_create_ischema_args(const ThriftHiveMetastore_create_ischema_args&); + ThriftHiveMetastore_create_ischema_args& operator=(const ThriftHiveMetastore_create_ischema_args&); + ThriftHiveMetastore_create_ischema_args() noexcept; + + virtual ~ThriftHiveMetastore_create_ischema_args() noexcept; + ISchema schema; + + _ThriftHiveMetastore_create_ischema_args__isset __isset; + + void __set_schema(const ISchema& val); + + bool operator == (const ThriftHiveMetastore_create_ischema_args & rhs) const; + bool operator != (const ThriftHiveMetastore_create_ischema_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_ischema_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_create_ischema_pargs { + public: + + + virtual ~ThriftHiveMetastore_create_ischema_pargs() noexcept; + const ISchema* schema; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_ischema_result__isset { + _ThriftHiveMetastore_create_ischema_result__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_create_ischema_result__isset; + +class ThriftHiveMetastore_create_ischema_result { + public: + + ThriftHiveMetastore_create_ischema_result(const ThriftHiveMetastore_create_ischema_result&); + ThriftHiveMetastore_create_ischema_result& operator=(const ThriftHiveMetastore_create_ischema_result&); + ThriftHiveMetastore_create_ischema_result() noexcept; + + virtual ~ThriftHiveMetastore_create_ischema_result() noexcept; + AlreadyExistsException o1; + NoSuchObjectException o2; + MetaException o3; + + _ThriftHiveMetastore_create_ischema_result__isset __isset; + + void __set_o1(const AlreadyExistsException& val); + + void __set_o2(const NoSuchObjectException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_create_ischema_result & rhs) const; + bool operator != (const ThriftHiveMetastore_create_ischema_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_ischema_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_ischema_presult__isset { + _ThriftHiveMetastore_create_ischema_presult__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_create_ischema_presult__isset; + +class ThriftHiveMetastore_create_ischema_presult { + public: + + + virtual ~ThriftHiveMetastore_create_ischema_presult() noexcept; + AlreadyExistsException o1; + NoSuchObjectException o2; + MetaException o3; + + _ThriftHiveMetastore_create_ischema_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_alter_ischema_args__isset { + _ThriftHiveMetastore_alter_ischema_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_alter_ischema_args__isset; + +class ThriftHiveMetastore_alter_ischema_args { + public: + + ThriftHiveMetastore_alter_ischema_args(const ThriftHiveMetastore_alter_ischema_args&); + ThriftHiveMetastore_alter_ischema_args& operator=(const ThriftHiveMetastore_alter_ischema_args&); + ThriftHiveMetastore_alter_ischema_args() noexcept; + + virtual ~ThriftHiveMetastore_alter_ischema_args() noexcept; + AlterISchemaRequest rqst; + + _ThriftHiveMetastore_alter_ischema_args__isset __isset; + + void __set_rqst(const AlterISchemaRequest& val); + + bool operator == (const ThriftHiveMetastore_alter_ischema_args & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_ischema_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_ischema_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_alter_ischema_pargs { + public: + + + virtual ~ThriftHiveMetastore_alter_ischema_pargs() noexcept; + const AlterISchemaRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_ischema_result__isset { + _ThriftHiveMetastore_alter_ischema_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_ischema_result__isset; + +class ThriftHiveMetastore_alter_ischema_result { + public: + + ThriftHiveMetastore_alter_ischema_result(const ThriftHiveMetastore_alter_ischema_result&); + ThriftHiveMetastore_alter_ischema_result& operator=(const ThriftHiveMetastore_alter_ischema_result&); + ThriftHiveMetastore_alter_ischema_result() noexcept; + + virtual ~ThriftHiveMetastore_alter_ischema_result() noexcept; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_ischema_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_alter_ischema_result & rhs) const; + bool operator != (const ThriftHiveMetastore_alter_ischema_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_ischema_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_ischema_presult__isset { + _ThriftHiveMetastore_alter_ischema_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_alter_ischema_presult__isset; + +class ThriftHiveMetastore_alter_ischema_presult { + public: + + + virtual ~ThriftHiveMetastore_alter_ischema_presult() noexcept; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_ischema_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_ischema_args__isset { + _ThriftHiveMetastore_get_ischema_args__isset() : name(false) {} + bool name :1; +} _ThriftHiveMetastore_get_ischema_args__isset; + +class ThriftHiveMetastore_get_ischema_args { + public: + + ThriftHiveMetastore_get_ischema_args(const ThriftHiveMetastore_get_ischema_args&); + ThriftHiveMetastore_get_ischema_args& operator=(const ThriftHiveMetastore_get_ischema_args&); + ThriftHiveMetastore_get_ischema_args() noexcept; + + virtual ~ThriftHiveMetastore_get_ischema_args() noexcept; + ISchemaName name; + + _ThriftHiveMetastore_get_ischema_args__isset __isset; + + void __set_name(const ISchemaName& val); + + bool operator == (const ThriftHiveMetastore_get_ischema_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_ischema_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_ischema_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_ischema_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_ischema_pargs() noexcept; + const ISchemaName* name; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_ischema_result__isset { + _ThriftHiveMetastore_get_ischema_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_ischema_result__isset; + +class ThriftHiveMetastore_get_ischema_result { + public: + + ThriftHiveMetastore_get_ischema_result(const ThriftHiveMetastore_get_ischema_result&); + ThriftHiveMetastore_get_ischema_result& operator=(const ThriftHiveMetastore_get_ischema_result&); + ThriftHiveMetastore_get_ischema_result() noexcept; + + virtual ~ThriftHiveMetastore_get_ischema_result() noexcept; + ISchema success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_ischema_result__isset __isset; + + void __set_success(const ISchema& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_ischema_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_ischema_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_ischema_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_ischema_presult__isset { + _ThriftHiveMetastore_get_ischema_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_ischema_presult__isset; + +class ThriftHiveMetastore_get_ischema_presult { + public: + + + virtual ~ThriftHiveMetastore_get_ischema_presult() noexcept; + ISchema* success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_ischema_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_ischema_args__isset { + _ThriftHiveMetastore_drop_ischema_args__isset() : name(false) {} + bool name :1; +} _ThriftHiveMetastore_drop_ischema_args__isset; + +class ThriftHiveMetastore_drop_ischema_args { + public: + + ThriftHiveMetastore_drop_ischema_args(const ThriftHiveMetastore_drop_ischema_args&); + ThriftHiveMetastore_drop_ischema_args& operator=(const ThriftHiveMetastore_drop_ischema_args&); + ThriftHiveMetastore_drop_ischema_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_ischema_args() noexcept; + ISchemaName name; + + _ThriftHiveMetastore_drop_ischema_args__isset __isset; + + void __set_name(const ISchemaName& val); + + bool operator == (const ThriftHiveMetastore_drop_ischema_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_ischema_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_ischema_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_ischema_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_ischema_pargs() noexcept; + const ISchemaName* name; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_ischema_result__isset { + _ThriftHiveMetastore_drop_ischema_result__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_ischema_result__isset; + +class ThriftHiveMetastore_drop_ischema_result { + public: + + ThriftHiveMetastore_drop_ischema_result(const ThriftHiveMetastore_drop_ischema_result&); + ThriftHiveMetastore_drop_ischema_result& operator=(const ThriftHiveMetastore_drop_ischema_result&); + ThriftHiveMetastore_drop_ischema_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_ischema_result() noexcept; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_ischema_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const InvalidOperationException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_ischema_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_ischema_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_ischema_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_ischema_presult__isset { + _ThriftHiveMetastore_drop_ischema_presult__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_ischema_presult__isset; + +class ThriftHiveMetastore_drop_ischema_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_ischema_presult() noexcept; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_ischema_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_add_schema_version_args__isset { + _ThriftHiveMetastore_add_schema_version_args__isset() : schemaVersion(false) {} + bool schemaVersion :1; +} _ThriftHiveMetastore_add_schema_version_args__isset; + +class ThriftHiveMetastore_add_schema_version_args { + public: + + ThriftHiveMetastore_add_schema_version_args(const ThriftHiveMetastore_add_schema_version_args&); + ThriftHiveMetastore_add_schema_version_args& operator=(const ThriftHiveMetastore_add_schema_version_args&); + ThriftHiveMetastore_add_schema_version_args() noexcept; + + virtual ~ThriftHiveMetastore_add_schema_version_args() noexcept; + SchemaVersion schemaVersion; + + _ThriftHiveMetastore_add_schema_version_args__isset __isset; + + void __set_schemaVersion(const SchemaVersion& val); + + bool operator == (const ThriftHiveMetastore_add_schema_version_args & rhs) const; + bool operator != (const ThriftHiveMetastore_add_schema_version_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_schema_version_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_schema_version_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_schema_version_pargs() noexcept; + const SchemaVersion* schemaVersion; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_schema_version_result__isset { + _ThriftHiveMetastore_add_schema_version_result__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_add_schema_version_result__isset; + +class ThriftHiveMetastore_add_schema_version_result { + public: + + ThriftHiveMetastore_add_schema_version_result(const ThriftHiveMetastore_add_schema_version_result&); + ThriftHiveMetastore_add_schema_version_result& operator=(const ThriftHiveMetastore_add_schema_version_result&); + ThriftHiveMetastore_add_schema_version_result() noexcept; + + virtual ~ThriftHiveMetastore_add_schema_version_result() noexcept; + AlreadyExistsException o1; + NoSuchObjectException o2; + MetaException o3; + + _ThriftHiveMetastore_add_schema_version_result__isset __isset; + + void __set_o1(const AlreadyExistsException& val); + + void __set_o2(const NoSuchObjectException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_add_schema_version_result & rhs) const; + bool operator != (const ThriftHiveMetastore_add_schema_version_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_schema_version_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_schema_version_presult__isset { + _ThriftHiveMetastore_add_schema_version_presult__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_add_schema_version_presult__isset; + +class ThriftHiveMetastore_add_schema_version_presult { + public: + + + virtual ~ThriftHiveMetastore_add_schema_version_presult() noexcept; + AlreadyExistsException o1; + NoSuchObjectException o2; + MetaException o3; + + _ThriftHiveMetastore_add_schema_version_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_schema_version_args__isset { + _ThriftHiveMetastore_get_schema_version_args__isset() : schemaVersion(false) {} + bool schemaVersion :1; +} _ThriftHiveMetastore_get_schema_version_args__isset; + +class ThriftHiveMetastore_get_schema_version_args { + public: + + ThriftHiveMetastore_get_schema_version_args(const ThriftHiveMetastore_get_schema_version_args&); + ThriftHiveMetastore_get_schema_version_args& operator=(const ThriftHiveMetastore_get_schema_version_args&); + ThriftHiveMetastore_get_schema_version_args() noexcept; + + virtual ~ThriftHiveMetastore_get_schema_version_args() noexcept; + SchemaVersionDescriptor schemaVersion; + + _ThriftHiveMetastore_get_schema_version_args__isset __isset; + + void __set_schemaVersion(const SchemaVersionDescriptor& val); + + bool operator == (const ThriftHiveMetastore_get_schema_version_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_schema_version_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_schema_version_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_schema_version_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_schema_version_pargs() noexcept; + const SchemaVersionDescriptor* schemaVersion; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_schema_version_result__isset { + _ThriftHiveMetastore_get_schema_version_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_schema_version_result__isset; + +class ThriftHiveMetastore_get_schema_version_result { + public: + + ThriftHiveMetastore_get_schema_version_result(const ThriftHiveMetastore_get_schema_version_result&); + ThriftHiveMetastore_get_schema_version_result& operator=(const ThriftHiveMetastore_get_schema_version_result&); + ThriftHiveMetastore_get_schema_version_result() noexcept; + + virtual ~ThriftHiveMetastore_get_schema_version_result() noexcept; + SchemaVersion success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_schema_version_result__isset __isset; + + void __set_success(const SchemaVersion& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_schema_version_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_schema_version_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_schema_version_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_schema_version_presult__isset { + _ThriftHiveMetastore_get_schema_version_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_schema_version_presult__isset; + +class ThriftHiveMetastore_get_schema_version_presult { + public: + + + virtual ~ThriftHiveMetastore_get_schema_version_presult() noexcept; + SchemaVersion* success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_schema_version_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_schema_latest_version_args__isset { + _ThriftHiveMetastore_get_schema_latest_version_args__isset() : schemaName(false) {} + bool schemaName :1; +} _ThriftHiveMetastore_get_schema_latest_version_args__isset; + +class ThriftHiveMetastore_get_schema_latest_version_args { + public: + + ThriftHiveMetastore_get_schema_latest_version_args(const ThriftHiveMetastore_get_schema_latest_version_args&); + ThriftHiveMetastore_get_schema_latest_version_args& operator=(const ThriftHiveMetastore_get_schema_latest_version_args&); + ThriftHiveMetastore_get_schema_latest_version_args() noexcept; + + virtual ~ThriftHiveMetastore_get_schema_latest_version_args() noexcept; + ISchemaName schemaName; + + _ThriftHiveMetastore_get_schema_latest_version_args__isset __isset; + + void __set_schemaName(const ISchemaName& val); + + bool operator == (const ThriftHiveMetastore_get_schema_latest_version_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_schema_latest_version_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_schema_latest_version_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_schema_latest_version_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_schema_latest_version_pargs() noexcept; + const ISchemaName* schemaName; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_schema_latest_version_result__isset { + _ThriftHiveMetastore_get_schema_latest_version_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_schema_latest_version_result__isset; + +class ThriftHiveMetastore_get_schema_latest_version_result { + public: + + ThriftHiveMetastore_get_schema_latest_version_result(const ThriftHiveMetastore_get_schema_latest_version_result&); + ThriftHiveMetastore_get_schema_latest_version_result& operator=(const ThriftHiveMetastore_get_schema_latest_version_result&); + ThriftHiveMetastore_get_schema_latest_version_result() noexcept; + + virtual ~ThriftHiveMetastore_get_schema_latest_version_result() noexcept; + SchemaVersion success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_schema_latest_version_result__isset __isset; + + void __set_success(const SchemaVersion& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_schema_latest_version_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_schema_latest_version_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_schema_latest_version_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_schema_latest_version_presult__isset { + _ThriftHiveMetastore_get_schema_latest_version_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_schema_latest_version_presult__isset; + +class ThriftHiveMetastore_get_schema_latest_version_presult { + public: + + + virtual ~ThriftHiveMetastore_get_schema_latest_version_presult() noexcept; + SchemaVersion* success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_schema_latest_version_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_schema_all_versions_args__isset { + _ThriftHiveMetastore_get_schema_all_versions_args__isset() : schemaName(false) {} + bool schemaName :1; +} _ThriftHiveMetastore_get_schema_all_versions_args__isset; + +class ThriftHiveMetastore_get_schema_all_versions_args { + public: + + ThriftHiveMetastore_get_schema_all_versions_args(const ThriftHiveMetastore_get_schema_all_versions_args&); + ThriftHiveMetastore_get_schema_all_versions_args& operator=(const ThriftHiveMetastore_get_schema_all_versions_args&); + ThriftHiveMetastore_get_schema_all_versions_args() noexcept; + + virtual ~ThriftHiveMetastore_get_schema_all_versions_args() noexcept; + ISchemaName schemaName; + + _ThriftHiveMetastore_get_schema_all_versions_args__isset __isset; + + void __set_schemaName(const ISchemaName& val); + + bool operator == (const ThriftHiveMetastore_get_schema_all_versions_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_schema_all_versions_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_schema_all_versions_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_schema_all_versions_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_schema_all_versions_pargs() noexcept; + const ISchemaName* schemaName; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_schema_all_versions_result__isset { + _ThriftHiveMetastore_get_schema_all_versions_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_schema_all_versions_result__isset; + +class ThriftHiveMetastore_get_schema_all_versions_result { + public: + + ThriftHiveMetastore_get_schema_all_versions_result(const ThriftHiveMetastore_get_schema_all_versions_result&); + ThriftHiveMetastore_get_schema_all_versions_result& operator=(const ThriftHiveMetastore_get_schema_all_versions_result&); + ThriftHiveMetastore_get_schema_all_versions_result() noexcept; + + virtual ~ThriftHiveMetastore_get_schema_all_versions_result() noexcept; + std::vector success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_schema_all_versions_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_schema_all_versions_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_schema_all_versions_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_schema_all_versions_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_schema_all_versions_presult__isset { + _ThriftHiveMetastore_get_schema_all_versions_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_schema_all_versions_presult__isset; + +class ThriftHiveMetastore_get_schema_all_versions_presult { + public: + + + virtual ~ThriftHiveMetastore_get_schema_all_versions_presult() noexcept; + std::vector * success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_schema_all_versions_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_schema_version_args__isset { + _ThriftHiveMetastore_drop_schema_version_args__isset() : schemaVersion(false) {} + bool schemaVersion :1; +} _ThriftHiveMetastore_drop_schema_version_args__isset; + +class ThriftHiveMetastore_drop_schema_version_args { + public: + + ThriftHiveMetastore_drop_schema_version_args(const ThriftHiveMetastore_drop_schema_version_args&); + ThriftHiveMetastore_drop_schema_version_args& operator=(const ThriftHiveMetastore_drop_schema_version_args&); + ThriftHiveMetastore_drop_schema_version_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_schema_version_args() noexcept; + SchemaVersionDescriptor schemaVersion; + + _ThriftHiveMetastore_drop_schema_version_args__isset __isset; + + void __set_schemaVersion(const SchemaVersionDescriptor& val); + + bool operator == (const ThriftHiveMetastore_drop_schema_version_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_schema_version_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_schema_version_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_schema_version_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_schema_version_pargs() noexcept; + const SchemaVersionDescriptor* schemaVersion; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_schema_version_result__isset { + _ThriftHiveMetastore_drop_schema_version_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_drop_schema_version_result__isset; + +class ThriftHiveMetastore_drop_schema_version_result { + public: + + ThriftHiveMetastore_drop_schema_version_result(const ThriftHiveMetastore_drop_schema_version_result&); + ThriftHiveMetastore_drop_schema_version_result& operator=(const ThriftHiveMetastore_drop_schema_version_result&); + ThriftHiveMetastore_drop_schema_version_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_schema_version_result() noexcept; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_drop_schema_version_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_schema_version_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_schema_version_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_schema_version_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_schema_version_presult__isset { + _ThriftHiveMetastore_drop_schema_version_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_drop_schema_version_presult__isset; + +class ThriftHiveMetastore_drop_schema_version_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_schema_version_presult() noexcept; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_drop_schema_version_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_schemas_by_cols_args__isset { + _ThriftHiveMetastore_get_schemas_by_cols_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_get_schemas_by_cols_args__isset; + +class ThriftHiveMetastore_get_schemas_by_cols_args { + public: + + ThriftHiveMetastore_get_schemas_by_cols_args(const ThriftHiveMetastore_get_schemas_by_cols_args&); + ThriftHiveMetastore_get_schemas_by_cols_args& operator=(const ThriftHiveMetastore_get_schemas_by_cols_args&); + ThriftHiveMetastore_get_schemas_by_cols_args() noexcept; + + virtual ~ThriftHiveMetastore_get_schemas_by_cols_args() noexcept; + FindSchemasByColsRqst rqst; + + _ThriftHiveMetastore_get_schemas_by_cols_args__isset __isset; + + void __set_rqst(const FindSchemasByColsRqst& val); + + bool operator == (const ThriftHiveMetastore_get_schemas_by_cols_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_schemas_by_cols_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_schemas_by_cols_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_schemas_by_cols_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_schemas_by_cols_pargs() noexcept; + const FindSchemasByColsRqst* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_schemas_by_cols_result__isset { + _ThriftHiveMetastore_get_schemas_by_cols_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_schemas_by_cols_result__isset; + +class ThriftHiveMetastore_get_schemas_by_cols_result { + public: + + ThriftHiveMetastore_get_schemas_by_cols_result(const ThriftHiveMetastore_get_schemas_by_cols_result&); + ThriftHiveMetastore_get_schemas_by_cols_result& operator=(const ThriftHiveMetastore_get_schemas_by_cols_result&); + ThriftHiveMetastore_get_schemas_by_cols_result() noexcept; + + virtual ~ThriftHiveMetastore_get_schemas_by_cols_result() noexcept; + FindSchemasByColsResp success; + MetaException o1; + + _ThriftHiveMetastore_get_schemas_by_cols_result__isset __isset; + + void __set_success(const FindSchemasByColsResp& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_schemas_by_cols_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_schemas_by_cols_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_schemas_by_cols_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_schemas_by_cols_presult__isset { + _ThriftHiveMetastore_get_schemas_by_cols_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_schemas_by_cols_presult__isset; + +class ThriftHiveMetastore_get_schemas_by_cols_presult { + public: + + + virtual ~ThriftHiveMetastore_get_schemas_by_cols_presult() noexcept; + FindSchemasByColsResp* success; + MetaException o1; + + _ThriftHiveMetastore_get_schemas_by_cols_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_map_schema_version_to_serde_args__isset { + _ThriftHiveMetastore_map_schema_version_to_serde_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_map_schema_version_to_serde_args__isset; + +class ThriftHiveMetastore_map_schema_version_to_serde_args { + public: + + ThriftHiveMetastore_map_schema_version_to_serde_args(const ThriftHiveMetastore_map_schema_version_to_serde_args&); + ThriftHiveMetastore_map_schema_version_to_serde_args& operator=(const ThriftHiveMetastore_map_schema_version_to_serde_args&); + ThriftHiveMetastore_map_schema_version_to_serde_args() noexcept; + + virtual ~ThriftHiveMetastore_map_schema_version_to_serde_args() noexcept; + MapSchemaVersionToSerdeRequest rqst; + + _ThriftHiveMetastore_map_schema_version_to_serde_args__isset __isset; + + void __set_rqst(const MapSchemaVersionToSerdeRequest& val); + + bool operator == (const ThriftHiveMetastore_map_schema_version_to_serde_args & rhs) const; + bool operator != (const ThriftHiveMetastore_map_schema_version_to_serde_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_map_schema_version_to_serde_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_map_schema_version_to_serde_pargs { + public: + + + virtual ~ThriftHiveMetastore_map_schema_version_to_serde_pargs() noexcept; + const MapSchemaVersionToSerdeRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_map_schema_version_to_serde_result__isset { + _ThriftHiveMetastore_map_schema_version_to_serde_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_map_schema_version_to_serde_result__isset; + +class ThriftHiveMetastore_map_schema_version_to_serde_result { + public: + + ThriftHiveMetastore_map_schema_version_to_serde_result(const ThriftHiveMetastore_map_schema_version_to_serde_result&); + ThriftHiveMetastore_map_schema_version_to_serde_result& operator=(const ThriftHiveMetastore_map_schema_version_to_serde_result&); + ThriftHiveMetastore_map_schema_version_to_serde_result() noexcept; + + virtual ~ThriftHiveMetastore_map_schema_version_to_serde_result() noexcept; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_map_schema_version_to_serde_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_map_schema_version_to_serde_result & rhs) const; + bool operator != (const ThriftHiveMetastore_map_schema_version_to_serde_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_map_schema_version_to_serde_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_map_schema_version_to_serde_presult__isset { + _ThriftHiveMetastore_map_schema_version_to_serde_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_map_schema_version_to_serde_presult__isset; + +class ThriftHiveMetastore_map_schema_version_to_serde_presult { + public: + + + virtual ~ThriftHiveMetastore_map_schema_version_to_serde_presult() noexcept; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_map_schema_version_to_serde_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_set_schema_version_state_args__isset { + _ThriftHiveMetastore_set_schema_version_state_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_set_schema_version_state_args__isset; + +class ThriftHiveMetastore_set_schema_version_state_args { + public: + + ThriftHiveMetastore_set_schema_version_state_args(const ThriftHiveMetastore_set_schema_version_state_args&); + ThriftHiveMetastore_set_schema_version_state_args& operator=(const ThriftHiveMetastore_set_schema_version_state_args&); + ThriftHiveMetastore_set_schema_version_state_args() noexcept; + + virtual ~ThriftHiveMetastore_set_schema_version_state_args() noexcept; + SetSchemaVersionStateRequest rqst; + + _ThriftHiveMetastore_set_schema_version_state_args__isset __isset; + + void __set_rqst(const SetSchemaVersionStateRequest& val); + + bool operator == (const ThriftHiveMetastore_set_schema_version_state_args & rhs) const; + bool operator != (const ThriftHiveMetastore_set_schema_version_state_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_set_schema_version_state_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_set_schema_version_state_pargs { + public: + + + virtual ~ThriftHiveMetastore_set_schema_version_state_pargs() noexcept; + const SetSchemaVersionStateRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_set_schema_version_state_result__isset { + _ThriftHiveMetastore_set_schema_version_state_result__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_set_schema_version_state_result__isset; + +class ThriftHiveMetastore_set_schema_version_state_result { + public: + + ThriftHiveMetastore_set_schema_version_state_result(const ThriftHiveMetastore_set_schema_version_state_result&); + ThriftHiveMetastore_set_schema_version_state_result& operator=(const ThriftHiveMetastore_set_schema_version_state_result&); + ThriftHiveMetastore_set_schema_version_state_result() noexcept; + + virtual ~ThriftHiveMetastore_set_schema_version_state_result() noexcept; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_set_schema_version_state_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const InvalidOperationException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_set_schema_version_state_result & rhs) const; + bool operator != (const ThriftHiveMetastore_set_schema_version_state_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_set_schema_version_state_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_set_schema_version_state_presult__isset { + _ThriftHiveMetastore_set_schema_version_state_presult__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_set_schema_version_state_presult__isset; + +class ThriftHiveMetastore_set_schema_version_state_presult { + public: + + + virtual ~ThriftHiveMetastore_set_schema_version_state_presult() noexcept; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_set_schema_version_state_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_add_serde_args__isset { + _ThriftHiveMetastore_add_serde_args__isset() : serde(false) {} + bool serde :1; +} _ThriftHiveMetastore_add_serde_args__isset; + +class ThriftHiveMetastore_add_serde_args { + public: + + ThriftHiveMetastore_add_serde_args(const ThriftHiveMetastore_add_serde_args&); + ThriftHiveMetastore_add_serde_args& operator=(const ThriftHiveMetastore_add_serde_args&); + ThriftHiveMetastore_add_serde_args() noexcept; + + virtual ~ThriftHiveMetastore_add_serde_args() noexcept; + SerDeInfo serde; + + _ThriftHiveMetastore_add_serde_args__isset __isset; + + void __set_serde(const SerDeInfo& val); + + bool operator == (const ThriftHiveMetastore_add_serde_args & rhs) const; + bool operator != (const ThriftHiveMetastore_add_serde_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_serde_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_serde_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_serde_pargs() noexcept; + const SerDeInfo* serde; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_serde_result__isset { + _ThriftHiveMetastore_add_serde_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_add_serde_result__isset; + +class ThriftHiveMetastore_add_serde_result { + public: + + ThriftHiveMetastore_add_serde_result(const ThriftHiveMetastore_add_serde_result&); + ThriftHiveMetastore_add_serde_result& operator=(const ThriftHiveMetastore_add_serde_result&); + ThriftHiveMetastore_add_serde_result() noexcept; + + virtual ~ThriftHiveMetastore_add_serde_result() noexcept; + AlreadyExistsException o1; + MetaException o2; + + _ThriftHiveMetastore_add_serde_result__isset __isset; + + void __set_o1(const AlreadyExistsException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_add_serde_result & rhs) const; + bool operator != (const ThriftHiveMetastore_add_serde_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_serde_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_serde_presult__isset { + _ThriftHiveMetastore_add_serde_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_add_serde_presult__isset; + +class ThriftHiveMetastore_add_serde_presult { + public: + + + virtual ~ThriftHiveMetastore_add_serde_presult() noexcept; + AlreadyExistsException o1; + MetaException o2; + + _ThriftHiveMetastore_add_serde_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_serde_args__isset { + _ThriftHiveMetastore_get_serde_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_get_serde_args__isset; + +class ThriftHiveMetastore_get_serde_args { + public: + + ThriftHiveMetastore_get_serde_args(const ThriftHiveMetastore_get_serde_args&); + ThriftHiveMetastore_get_serde_args& operator=(const ThriftHiveMetastore_get_serde_args&); + ThriftHiveMetastore_get_serde_args() noexcept; + + virtual ~ThriftHiveMetastore_get_serde_args() noexcept; + GetSerdeRequest rqst; + + _ThriftHiveMetastore_get_serde_args__isset __isset; + + void __set_rqst(const GetSerdeRequest& val); + + bool operator == (const ThriftHiveMetastore_get_serde_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_serde_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_serde_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_serde_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_serde_pargs() noexcept; + const GetSerdeRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_serde_result__isset { + _ThriftHiveMetastore_get_serde_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_serde_result__isset; + +class ThriftHiveMetastore_get_serde_result { + public: + + ThriftHiveMetastore_get_serde_result(const ThriftHiveMetastore_get_serde_result&); + ThriftHiveMetastore_get_serde_result& operator=(const ThriftHiveMetastore_get_serde_result&); + ThriftHiveMetastore_get_serde_result() noexcept; + + virtual ~ThriftHiveMetastore_get_serde_result() noexcept; + SerDeInfo success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_serde_result__isset __isset; + + void __set_success(const SerDeInfo& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_serde_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_serde_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_serde_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_serde_presult__isset { + _ThriftHiveMetastore_get_serde_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_serde_presult__isset; + +class ThriftHiveMetastore_get_serde_presult { + public: + + + virtual ~ThriftHiveMetastore_get_serde_presult() noexcept; + SerDeInfo* success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_serde_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_lock_materialization_rebuild_args__isset { + _ThriftHiveMetastore_get_lock_materialization_rebuild_args__isset() : dbName(false), tableName(false), txnId(false) {} + bool dbName :1; + bool tableName :1; + bool txnId :1; +} _ThriftHiveMetastore_get_lock_materialization_rebuild_args__isset; + +class ThriftHiveMetastore_get_lock_materialization_rebuild_args { + public: + + ThriftHiveMetastore_get_lock_materialization_rebuild_args(const ThriftHiveMetastore_get_lock_materialization_rebuild_args&); + ThriftHiveMetastore_get_lock_materialization_rebuild_args& operator=(const ThriftHiveMetastore_get_lock_materialization_rebuild_args&); + ThriftHiveMetastore_get_lock_materialization_rebuild_args() noexcept; + + virtual ~ThriftHiveMetastore_get_lock_materialization_rebuild_args() noexcept; + std::string dbName; + std::string tableName; + int64_t txnId; + + _ThriftHiveMetastore_get_lock_materialization_rebuild_args__isset __isset; + + void __set_dbName(const std::string& val); + + void __set_tableName(const std::string& val); + + void __set_txnId(const int64_t val); + + bool operator == (const ThriftHiveMetastore_get_lock_materialization_rebuild_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_lock_materialization_rebuild_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_lock_materialization_rebuild_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_lock_materialization_rebuild_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_lock_materialization_rebuild_pargs() noexcept; + const std::string* dbName; + const std::string* tableName; + const int64_t* txnId; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_lock_materialization_rebuild_result__isset { + _ThriftHiveMetastore_get_lock_materialization_rebuild_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_lock_materialization_rebuild_result__isset; + +class ThriftHiveMetastore_get_lock_materialization_rebuild_result { + public: + + ThriftHiveMetastore_get_lock_materialization_rebuild_result(const ThriftHiveMetastore_get_lock_materialization_rebuild_result&); + ThriftHiveMetastore_get_lock_materialization_rebuild_result& operator=(const ThriftHiveMetastore_get_lock_materialization_rebuild_result&); + ThriftHiveMetastore_get_lock_materialization_rebuild_result() noexcept; + + virtual ~ThriftHiveMetastore_get_lock_materialization_rebuild_result() noexcept; + LockResponse success; + + _ThriftHiveMetastore_get_lock_materialization_rebuild_result__isset __isset; + + void __set_success(const LockResponse& val); + + bool operator == (const ThriftHiveMetastore_get_lock_materialization_rebuild_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_lock_materialization_rebuild_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_lock_materialization_rebuild_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_lock_materialization_rebuild_presult__isset { + _ThriftHiveMetastore_get_lock_materialization_rebuild_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_lock_materialization_rebuild_presult__isset; + +class ThriftHiveMetastore_get_lock_materialization_rebuild_presult { + public: + + + virtual ~ThriftHiveMetastore_get_lock_materialization_rebuild_presult() noexcept; + LockResponse* success; + + _ThriftHiveMetastore_get_lock_materialization_rebuild_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args__isset { + _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args__isset() : dbName(false), tableName(false), txnId(false) {} + bool dbName :1; + bool tableName :1; + bool txnId :1; +} _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args__isset; + +class ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args { + public: + + ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args(const ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args&); + ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args& operator=(const ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args&); + ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args() noexcept; + + virtual ~ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args() noexcept; + std::string dbName; + std::string tableName; + int64_t txnId; + + _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args__isset __isset; + + void __set_dbName(const std::string& val); + + void __set_tableName(const std::string& val); + + void __set_txnId(const int64_t val); + + bool operator == (const ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args & rhs) const; + bool operator != (const ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_pargs { + public: + + + virtual ~ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_pargs() noexcept; + const std::string* dbName; + const std::string* tableName; + const int64_t* txnId; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result__isset { + _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result__isset; + +class ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result { + public: + + ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result(const ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result&) noexcept; + ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result& operator=(const ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result&) noexcept; + ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result() noexcept; + + virtual ~ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result() noexcept; + bool success; + + _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result__isset __isset; + + void __set_success(const bool val); + + bool operator == (const ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result & rhs) const; + bool operator != (const ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult__isset { + _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult__isset; + +class ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult { + public: + + + virtual ~ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult() noexcept; + bool* success; + + _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_add_runtime_stats_args__isset { + _ThriftHiveMetastore_add_runtime_stats_args__isset() : stat(false) {} + bool stat :1; +} _ThriftHiveMetastore_add_runtime_stats_args__isset; + +class ThriftHiveMetastore_add_runtime_stats_args { + public: + + ThriftHiveMetastore_add_runtime_stats_args(const ThriftHiveMetastore_add_runtime_stats_args&); + ThriftHiveMetastore_add_runtime_stats_args& operator=(const ThriftHiveMetastore_add_runtime_stats_args&); + ThriftHiveMetastore_add_runtime_stats_args() noexcept; + + virtual ~ThriftHiveMetastore_add_runtime_stats_args() noexcept; + RuntimeStat stat; + + _ThriftHiveMetastore_add_runtime_stats_args__isset __isset; + + void __set_stat(const RuntimeStat& val); + + bool operator == (const ThriftHiveMetastore_add_runtime_stats_args & rhs) const; + bool operator != (const ThriftHiveMetastore_add_runtime_stats_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_runtime_stats_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_runtime_stats_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_runtime_stats_pargs() noexcept; + const RuntimeStat* stat; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_runtime_stats_result__isset { + _ThriftHiveMetastore_add_runtime_stats_result__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_add_runtime_stats_result__isset; + +class ThriftHiveMetastore_add_runtime_stats_result { + public: + + ThriftHiveMetastore_add_runtime_stats_result(const ThriftHiveMetastore_add_runtime_stats_result&); + ThriftHiveMetastore_add_runtime_stats_result& operator=(const ThriftHiveMetastore_add_runtime_stats_result&); + ThriftHiveMetastore_add_runtime_stats_result() noexcept; + + virtual ~ThriftHiveMetastore_add_runtime_stats_result() noexcept; + MetaException o1; + + _ThriftHiveMetastore_add_runtime_stats_result__isset __isset; + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_add_runtime_stats_result & rhs) const; + bool operator != (const ThriftHiveMetastore_add_runtime_stats_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_runtime_stats_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_runtime_stats_presult__isset { + _ThriftHiveMetastore_add_runtime_stats_presult__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_add_runtime_stats_presult__isset; + +class ThriftHiveMetastore_add_runtime_stats_presult { + public: + + + virtual ~ThriftHiveMetastore_add_runtime_stats_presult() noexcept; + MetaException o1; + + _ThriftHiveMetastore_add_runtime_stats_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_runtime_stats_args__isset { + _ThriftHiveMetastore_get_runtime_stats_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_get_runtime_stats_args__isset; + +class ThriftHiveMetastore_get_runtime_stats_args { + public: + + ThriftHiveMetastore_get_runtime_stats_args(const ThriftHiveMetastore_get_runtime_stats_args&) noexcept; + ThriftHiveMetastore_get_runtime_stats_args& operator=(const ThriftHiveMetastore_get_runtime_stats_args&) noexcept; + ThriftHiveMetastore_get_runtime_stats_args() noexcept; + + virtual ~ThriftHiveMetastore_get_runtime_stats_args() noexcept; + GetRuntimeStatsRequest rqst; + + _ThriftHiveMetastore_get_runtime_stats_args__isset __isset; + + void __set_rqst(const GetRuntimeStatsRequest& val); + + bool operator == (const ThriftHiveMetastore_get_runtime_stats_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_runtime_stats_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_runtime_stats_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_runtime_stats_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_runtime_stats_pargs() noexcept; + const GetRuntimeStatsRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_runtime_stats_result__isset { + _ThriftHiveMetastore_get_runtime_stats_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_runtime_stats_result__isset; + +class ThriftHiveMetastore_get_runtime_stats_result { + public: + + ThriftHiveMetastore_get_runtime_stats_result(const ThriftHiveMetastore_get_runtime_stats_result&); + ThriftHiveMetastore_get_runtime_stats_result& operator=(const ThriftHiveMetastore_get_runtime_stats_result&); + ThriftHiveMetastore_get_runtime_stats_result() noexcept; + + virtual ~ThriftHiveMetastore_get_runtime_stats_result() noexcept; + std::vector success; + MetaException o1; + + _ThriftHiveMetastore_get_runtime_stats_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_runtime_stats_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_runtime_stats_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_runtime_stats_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_runtime_stats_presult__isset { + _ThriftHiveMetastore_get_runtime_stats_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_runtime_stats_presult__isset; + +class ThriftHiveMetastore_get_runtime_stats_presult { + public: + + + virtual ~ThriftHiveMetastore_get_runtime_stats_presult() noexcept; + std::vector * success; + MetaException o1; + + _ThriftHiveMetastore_get_runtime_stats_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_with_specs_args__isset { + _ThriftHiveMetastore_get_partitions_with_specs_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_partitions_with_specs_args__isset; + +class ThriftHiveMetastore_get_partitions_with_specs_args { + public: + + ThriftHiveMetastore_get_partitions_with_specs_args(const ThriftHiveMetastore_get_partitions_with_specs_args&); + ThriftHiveMetastore_get_partitions_with_specs_args& operator=(const ThriftHiveMetastore_get_partitions_with_specs_args&); + ThriftHiveMetastore_get_partitions_with_specs_args() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_with_specs_args() noexcept; + GetPartitionsRequest request; + + _ThriftHiveMetastore_get_partitions_with_specs_args__isset __isset; + + void __set_request(const GetPartitionsRequest& val); + + bool operator == (const ThriftHiveMetastore_get_partitions_with_specs_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_with_specs_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_with_specs_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_partitions_with_specs_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_with_specs_pargs() noexcept; + const GetPartitionsRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_with_specs_result__isset { + _ThriftHiveMetastore_get_partitions_with_specs_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_partitions_with_specs_result__isset; + +class ThriftHiveMetastore_get_partitions_with_specs_result { + public: + + ThriftHiveMetastore_get_partitions_with_specs_result(const ThriftHiveMetastore_get_partitions_with_specs_result&); + ThriftHiveMetastore_get_partitions_with_specs_result& operator=(const ThriftHiveMetastore_get_partitions_with_specs_result&); + ThriftHiveMetastore_get_partitions_with_specs_result() noexcept; + + virtual ~ThriftHiveMetastore_get_partitions_with_specs_result() noexcept; + GetPartitionsResponse success; + MetaException o1; + + _ThriftHiveMetastore_get_partitions_with_specs_result__isset __isset; + + void __set_success(const GetPartitionsResponse& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_partitions_with_specs_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_partitions_with_specs_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_partitions_with_specs_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_partitions_with_specs_presult__isset { + _ThriftHiveMetastore_get_partitions_with_specs_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_partitions_with_specs_presult__isset; + +class ThriftHiveMetastore_get_partitions_with_specs_presult { + public: + + + virtual ~ThriftHiveMetastore_get_partitions_with_specs_presult() noexcept; + GetPartitionsResponse* success; + MetaException o1; + + _ThriftHiveMetastore_get_partitions_with_specs_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_scheduled_query_poll_args__isset { + _ThriftHiveMetastore_scheduled_query_poll_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_scheduled_query_poll_args__isset; + +class ThriftHiveMetastore_scheduled_query_poll_args { + public: + + ThriftHiveMetastore_scheduled_query_poll_args(const ThriftHiveMetastore_scheduled_query_poll_args&); + ThriftHiveMetastore_scheduled_query_poll_args& operator=(const ThriftHiveMetastore_scheduled_query_poll_args&); + ThriftHiveMetastore_scheduled_query_poll_args() noexcept; + + virtual ~ThriftHiveMetastore_scheduled_query_poll_args() noexcept; + ScheduledQueryPollRequest request; + + _ThriftHiveMetastore_scheduled_query_poll_args__isset __isset; + + void __set_request(const ScheduledQueryPollRequest& val); + + bool operator == (const ThriftHiveMetastore_scheduled_query_poll_args & rhs) const; + bool operator != (const ThriftHiveMetastore_scheduled_query_poll_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_scheduled_query_poll_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_scheduled_query_poll_pargs { + public: + + + virtual ~ThriftHiveMetastore_scheduled_query_poll_pargs() noexcept; + const ScheduledQueryPollRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_scheduled_query_poll_result__isset { + _ThriftHiveMetastore_scheduled_query_poll_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_scheduled_query_poll_result__isset; + +class ThriftHiveMetastore_scheduled_query_poll_result { + public: + + ThriftHiveMetastore_scheduled_query_poll_result(const ThriftHiveMetastore_scheduled_query_poll_result&); + ThriftHiveMetastore_scheduled_query_poll_result& operator=(const ThriftHiveMetastore_scheduled_query_poll_result&); + ThriftHiveMetastore_scheduled_query_poll_result() noexcept; + + virtual ~ThriftHiveMetastore_scheduled_query_poll_result() noexcept; + ScheduledQueryPollResponse success; + MetaException o1; + + _ThriftHiveMetastore_scheduled_query_poll_result__isset __isset; + + void __set_success(const ScheduledQueryPollResponse& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_scheduled_query_poll_result & rhs) const; + bool operator != (const ThriftHiveMetastore_scheduled_query_poll_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_scheduled_query_poll_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_scheduled_query_poll_presult__isset { + _ThriftHiveMetastore_scheduled_query_poll_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_scheduled_query_poll_presult__isset; + +class ThriftHiveMetastore_scheduled_query_poll_presult { + public: + + + virtual ~ThriftHiveMetastore_scheduled_query_poll_presult() noexcept; + ScheduledQueryPollResponse* success; + MetaException o1; + + _ThriftHiveMetastore_scheduled_query_poll_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_scheduled_query_maintenance_args__isset { + _ThriftHiveMetastore_scheduled_query_maintenance_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_scheduled_query_maintenance_args__isset; + +class ThriftHiveMetastore_scheduled_query_maintenance_args { + public: + + ThriftHiveMetastore_scheduled_query_maintenance_args(const ThriftHiveMetastore_scheduled_query_maintenance_args&); + ThriftHiveMetastore_scheduled_query_maintenance_args& operator=(const ThriftHiveMetastore_scheduled_query_maintenance_args&); + ThriftHiveMetastore_scheduled_query_maintenance_args() noexcept; + + virtual ~ThriftHiveMetastore_scheduled_query_maintenance_args() noexcept; + ScheduledQueryMaintenanceRequest request; + + _ThriftHiveMetastore_scheduled_query_maintenance_args__isset __isset; + + void __set_request(const ScheduledQueryMaintenanceRequest& val); + + bool operator == (const ThriftHiveMetastore_scheduled_query_maintenance_args & rhs) const; + bool operator != (const ThriftHiveMetastore_scheduled_query_maintenance_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_scheduled_query_maintenance_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_scheduled_query_maintenance_pargs { + public: + + + virtual ~ThriftHiveMetastore_scheduled_query_maintenance_pargs() noexcept; + const ScheduledQueryMaintenanceRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_scheduled_query_maintenance_result__isset { + _ThriftHiveMetastore_scheduled_query_maintenance_result__isset() : o1(false), o2(false), o3(false), o4(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_scheduled_query_maintenance_result__isset; + +class ThriftHiveMetastore_scheduled_query_maintenance_result { + public: + + ThriftHiveMetastore_scheduled_query_maintenance_result(const ThriftHiveMetastore_scheduled_query_maintenance_result&); + ThriftHiveMetastore_scheduled_query_maintenance_result& operator=(const ThriftHiveMetastore_scheduled_query_maintenance_result&); + ThriftHiveMetastore_scheduled_query_maintenance_result() noexcept; + + virtual ~ThriftHiveMetastore_scheduled_query_maintenance_result() noexcept; + MetaException o1; + NoSuchObjectException o2; + AlreadyExistsException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_scheduled_query_maintenance_result__isset __isset; + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + void __set_o3(const AlreadyExistsException& val); + + void __set_o4(const InvalidInputException& val); + + bool operator == (const ThriftHiveMetastore_scheduled_query_maintenance_result & rhs) const; + bool operator != (const ThriftHiveMetastore_scheduled_query_maintenance_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_scheduled_query_maintenance_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_scheduled_query_maintenance_presult__isset { + _ThriftHiveMetastore_scheduled_query_maintenance_presult__isset() : o1(false), o2(false), o3(false), o4(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_scheduled_query_maintenance_presult__isset; + +class ThriftHiveMetastore_scheduled_query_maintenance_presult { + public: + + + virtual ~ThriftHiveMetastore_scheduled_query_maintenance_presult() noexcept; + MetaException o1; + NoSuchObjectException o2; + AlreadyExistsException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_scheduled_query_maintenance_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_scheduled_query_progress_args__isset { + _ThriftHiveMetastore_scheduled_query_progress_args__isset() : info(false) {} + bool info :1; +} _ThriftHiveMetastore_scheduled_query_progress_args__isset; + +class ThriftHiveMetastore_scheduled_query_progress_args { + public: + + ThriftHiveMetastore_scheduled_query_progress_args(const ThriftHiveMetastore_scheduled_query_progress_args&); + ThriftHiveMetastore_scheduled_query_progress_args& operator=(const ThriftHiveMetastore_scheduled_query_progress_args&); + ThriftHiveMetastore_scheduled_query_progress_args() noexcept; + + virtual ~ThriftHiveMetastore_scheduled_query_progress_args() noexcept; + ScheduledQueryProgressInfo info; + + _ThriftHiveMetastore_scheduled_query_progress_args__isset __isset; + + void __set_info(const ScheduledQueryProgressInfo& val); + + bool operator == (const ThriftHiveMetastore_scheduled_query_progress_args & rhs) const; + bool operator != (const ThriftHiveMetastore_scheduled_query_progress_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_scheduled_query_progress_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_scheduled_query_progress_pargs { + public: + + + virtual ~ThriftHiveMetastore_scheduled_query_progress_pargs() noexcept; + const ScheduledQueryProgressInfo* info; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_scheduled_query_progress_result__isset { + _ThriftHiveMetastore_scheduled_query_progress_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_scheduled_query_progress_result__isset; + +class ThriftHiveMetastore_scheduled_query_progress_result { + public: + + ThriftHiveMetastore_scheduled_query_progress_result(const ThriftHiveMetastore_scheduled_query_progress_result&); + ThriftHiveMetastore_scheduled_query_progress_result& operator=(const ThriftHiveMetastore_scheduled_query_progress_result&); + ThriftHiveMetastore_scheduled_query_progress_result() noexcept; + + virtual ~ThriftHiveMetastore_scheduled_query_progress_result() noexcept; + MetaException o1; + InvalidOperationException o2; + + _ThriftHiveMetastore_scheduled_query_progress_result__isset __isset; + + void __set_o1(const MetaException& val); + + void __set_o2(const InvalidOperationException& val); + + bool operator == (const ThriftHiveMetastore_scheduled_query_progress_result & rhs) const; + bool operator != (const ThriftHiveMetastore_scheduled_query_progress_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_scheduled_query_progress_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_scheduled_query_progress_presult__isset { + _ThriftHiveMetastore_scheduled_query_progress_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_scheduled_query_progress_presult__isset; + +class ThriftHiveMetastore_scheduled_query_progress_presult { + public: + + + virtual ~ThriftHiveMetastore_scheduled_query_progress_presult() noexcept; + MetaException o1; + InvalidOperationException o2; + + _ThriftHiveMetastore_scheduled_query_progress_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_scheduled_query_args__isset { + _ThriftHiveMetastore_get_scheduled_query_args__isset() : scheduleKey(false) {} + bool scheduleKey :1; +} _ThriftHiveMetastore_get_scheduled_query_args__isset; + +class ThriftHiveMetastore_get_scheduled_query_args { + public: + + ThriftHiveMetastore_get_scheduled_query_args(const ThriftHiveMetastore_get_scheduled_query_args&); + ThriftHiveMetastore_get_scheduled_query_args& operator=(const ThriftHiveMetastore_get_scheduled_query_args&); + ThriftHiveMetastore_get_scheduled_query_args() noexcept; + + virtual ~ThriftHiveMetastore_get_scheduled_query_args() noexcept; + ScheduledQueryKey scheduleKey; + + _ThriftHiveMetastore_get_scheduled_query_args__isset __isset; + + void __set_scheduleKey(const ScheduledQueryKey& val); + + bool operator == (const ThriftHiveMetastore_get_scheduled_query_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_scheduled_query_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_scheduled_query_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_scheduled_query_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_scheduled_query_pargs() noexcept; + const ScheduledQueryKey* scheduleKey; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_scheduled_query_result__isset { + _ThriftHiveMetastore_get_scheduled_query_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_scheduled_query_result__isset; + +class ThriftHiveMetastore_get_scheduled_query_result { + public: + + ThriftHiveMetastore_get_scheduled_query_result(const ThriftHiveMetastore_get_scheduled_query_result&); + ThriftHiveMetastore_get_scheduled_query_result& operator=(const ThriftHiveMetastore_get_scheduled_query_result&); + ThriftHiveMetastore_get_scheduled_query_result() noexcept; + + virtual ~ThriftHiveMetastore_get_scheduled_query_result() noexcept; + ScheduledQuery success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_scheduled_query_result__isset __isset; + + void __set_success(const ScheduledQuery& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_scheduled_query_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_scheduled_query_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_scheduled_query_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_scheduled_query_presult__isset { + _ThriftHiveMetastore_get_scheduled_query_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_scheduled_query_presult__isset; + +class ThriftHiveMetastore_get_scheduled_query_presult { + public: + + + virtual ~ThriftHiveMetastore_get_scheduled_query_presult() noexcept; + ScheduledQuery* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_scheduled_query_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_add_replication_metrics_args__isset { + _ThriftHiveMetastore_add_replication_metrics_args__isset() : replicationMetricList(false) {} + bool replicationMetricList :1; +} _ThriftHiveMetastore_add_replication_metrics_args__isset; + +class ThriftHiveMetastore_add_replication_metrics_args { + public: + + ThriftHiveMetastore_add_replication_metrics_args(const ThriftHiveMetastore_add_replication_metrics_args&); + ThriftHiveMetastore_add_replication_metrics_args& operator=(const ThriftHiveMetastore_add_replication_metrics_args&); + ThriftHiveMetastore_add_replication_metrics_args() noexcept; + + virtual ~ThriftHiveMetastore_add_replication_metrics_args() noexcept; + ReplicationMetricList replicationMetricList; + + _ThriftHiveMetastore_add_replication_metrics_args__isset __isset; + + void __set_replicationMetricList(const ReplicationMetricList& val); + + bool operator == (const ThriftHiveMetastore_add_replication_metrics_args & rhs) const; + bool operator != (const ThriftHiveMetastore_add_replication_metrics_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_replication_metrics_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_replication_metrics_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_replication_metrics_pargs() noexcept; + const ReplicationMetricList* replicationMetricList; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_replication_metrics_result__isset { + _ThriftHiveMetastore_add_replication_metrics_result__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_add_replication_metrics_result__isset; + +class ThriftHiveMetastore_add_replication_metrics_result { + public: + + ThriftHiveMetastore_add_replication_metrics_result(const ThriftHiveMetastore_add_replication_metrics_result&); + ThriftHiveMetastore_add_replication_metrics_result& operator=(const ThriftHiveMetastore_add_replication_metrics_result&); + ThriftHiveMetastore_add_replication_metrics_result() noexcept; + + virtual ~ThriftHiveMetastore_add_replication_metrics_result() noexcept; + MetaException o1; + + _ThriftHiveMetastore_add_replication_metrics_result__isset __isset; + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_add_replication_metrics_result & rhs) const; + bool operator != (const ThriftHiveMetastore_add_replication_metrics_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_replication_metrics_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_replication_metrics_presult__isset { + _ThriftHiveMetastore_add_replication_metrics_presult__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_add_replication_metrics_presult__isset; + +class ThriftHiveMetastore_add_replication_metrics_presult { + public: + + + virtual ~ThriftHiveMetastore_add_replication_metrics_presult() noexcept; + MetaException o1; + + _ThriftHiveMetastore_add_replication_metrics_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_replication_metrics_args__isset { + _ThriftHiveMetastore_get_replication_metrics_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_get_replication_metrics_args__isset; + +class ThriftHiveMetastore_get_replication_metrics_args { + public: + + ThriftHiveMetastore_get_replication_metrics_args(const ThriftHiveMetastore_get_replication_metrics_args&); + ThriftHiveMetastore_get_replication_metrics_args& operator=(const ThriftHiveMetastore_get_replication_metrics_args&); + ThriftHiveMetastore_get_replication_metrics_args() noexcept; + + virtual ~ThriftHiveMetastore_get_replication_metrics_args() noexcept; + GetReplicationMetricsRequest rqst; + + _ThriftHiveMetastore_get_replication_metrics_args__isset __isset; + + void __set_rqst(const GetReplicationMetricsRequest& val); + + bool operator == (const ThriftHiveMetastore_get_replication_metrics_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_replication_metrics_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_replication_metrics_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_replication_metrics_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_replication_metrics_pargs() noexcept; + const GetReplicationMetricsRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_replication_metrics_result__isset { + _ThriftHiveMetastore_get_replication_metrics_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_replication_metrics_result__isset; + +class ThriftHiveMetastore_get_replication_metrics_result { + public: + + ThriftHiveMetastore_get_replication_metrics_result(const ThriftHiveMetastore_get_replication_metrics_result&); + ThriftHiveMetastore_get_replication_metrics_result& operator=(const ThriftHiveMetastore_get_replication_metrics_result&); + ThriftHiveMetastore_get_replication_metrics_result() noexcept; + + virtual ~ThriftHiveMetastore_get_replication_metrics_result() noexcept; + ReplicationMetricList success; + MetaException o1; + + _ThriftHiveMetastore_get_replication_metrics_result__isset __isset; + + void __set_success(const ReplicationMetricList& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_replication_metrics_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_replication_metrics_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_replication_metrics_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_replication_metrics_presult__isset { + _ThriftHiveMetastore_get_replication_metrics_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_replication_metrics_presult__isset; + +class ThriftHiveMetastore_get_replication_metrics_presult { + public: + + + virtual ~ThriftHiveMetastore_get_replication_metrics_presult() noexcept; + ReplicationMetricList* success; + MetaException o1; + + _ThriftHiveMetastore_get_replication_metrics_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_open_txns_req_args__isset { + _ThriftHiveMetastore_get_open_txns_req_args__isset() : getOpenTxnsRequest(false) {} + bool getOpenTxnsRequest :1; +} _ThriftHiveMetastore_get_open_txns_req_args__isset; + +class ThriftHiveMetastore_get_open_txns_req_args { + public: + + ThriftHiveMetastore_get_open_txns_req_args(const ThriftHiveMetastore_get_open_txns_req_args&); + ThriftHiveMetastore_get_open_txns_req_args& operator=(const ThriftHiveMetastore_get_open_txns_req_args&); + ThriftHiveMetastore_get_open_txns_req_args() noexcept; + + virtual ~ThriftHiveMetastore_get_open_txns_req_args() noexcept; + GetOpenTxnsRequest getOpenTxnsRequest; + + _ThriftHiveMetastore_get_open_txns_req_args__isset __isset; + + void __set_getOpenTxnsRequest(const GetOpenTxnsRequest& val); + + bool operator == (const ThriftHiveMetastore_get_open_txns_req_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_open_txns_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_open_txns_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_open_txns_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_open_txns_req_pargs() noexcept; + const GetOpenTxnsRequest* getOpenTxnsRequest; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_open_txns_req_result__isset { + _ThriftHiveMetastore_get_open_txns_req_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_open_txns_req_result__isset; + +class ThriftHiveMetastore_get_open_txns_req_result { + public: + + ThriftHiveMetastore_get_open_txns_req_result(const ThriftHiveMetastore_get_open_txns_req_result&); + ThriftHiveMetastore_get_open_txns_req_result& operator=(const ThriftHiveMetastore_get_open_txns_req_result&); + ThriftHiveMetastore_get_open_txns_req_result() noexcept; + + virtual ~ThriftHiveMetastore_get_open_txns_req_result() noexcept; + GetOpenTxnsResponse success; + + _ThriftHiveMetastore_get_open_txns_req_result__isset __isset; + + void __set_success(const GetOpenTxnsResponse& val); + + bool operator == (const ThriftHiveMetastore_get_open_txns_req_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_open_txns_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_open_txns_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_open_txns_req_presult__isset { + _ThriftHiveMetastore_get_open_txns_req_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_open_txns_req_presult__isset; + +class ThriftHiveMetastore_get_open_txns_req_presult { + public: + + + virtual ~ThriftHiveMetastore_get_open_txns_req_presult() noexcept; + GetOpenTxnsResponse* success; + + _ThriftHiveMetastore_get_open_txns_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_create_stored_procedure_args__isset { + _ThriftHiveMetastore_create_stored_procedure_args__isset() : proc(false) {} + bool proc :1; +} _ThriftHiveMetastore_create_stored_procedure_args__isset; + +class ThriftHiveMetastore_create_stored_procedure_args { + public: + + ThriftHiveMetastore_create_stored_procedure_args(const ThriftHiveMetastore_create_stored_procedure_args&); + ThriftHiveMetastore_create_stored_procedure_args& operator=(const ThriftHiveMetastore_create_stored_procedure_args&); + ThriftHiveMetastore_create_stored_procedure_args() noexcept; + + virtual ~ThriftHiveMetastore_create_stored_procedure_args() noexcept; + StoredProcedure proc; + + _ThriftHiveMetastore_create_stored_procedure_args__isset __isset; + + void __set_proc(const StoredProcedure& val); + + bool operator == (const ThriftHiveMetastore_create_stored_procedure_args & rhs) const; + bool operator != (const ThriftHiveMetastore_create_stored_procedure_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_stored_procedure_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_create_stored_procedure_pargs { + public: + + + virtual ~ThriftHiveMetastore_create_stored_procedure_pargs() noexcept; + const StoredProcedure* proc; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_stored_procedure_result__isset { + _ThriftHiveMetastore_create_stored_procedure_result__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_create_stored_procedure_result__isset; + +class ThriftHiveMetastore_create_stored_procedure_result { + public: + + ThriftHiveMetastore_create_stored_procedure_result(const ThriftHiveMetastore_create_stored_procedure_result&); + ThriftHiveMetastore_create_stored_procedure_result& operator=(const ThriftHiveMetastore_create_stored_procedure_result&); + ThriftHiveMetastore_create_stored_procedure_result() noexcept; + + virtual ~ThriftHiveMetastore_create_stored_procedure_result() noexcept; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_create_stored_procedure_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_create_stored_procedure_result & rhs) const; + bool operator != (const ThriftHiveMetastore_create_stored_procedure_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_stored_procedure_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_stored_procedure_presult__isset { + _ThriftHiveMetastore_create_stored_procedure_presult__isset() : o1(false), o2(false) {} + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_create_stored_procedure_presult__isset; + +class ThriftHiveMetastore_create_stored_procedure_presult { + public: + + + virtual ~ThriftHiveMetastore_create_stored_procedure_presult() noexcept; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_create_stored_procedure_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_stored_procedure_args__isset { + _ThriftHiveMetastore_get_stored_procedure_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_stored_procedure_args__isset; + +class ThriftHiveMetastore_get_stored_procedure_args { + public: + + ThriftHiveMetastore_get_stored_procedure_args(const ThriftHiveMetastore_get_stored_procedure_args&); + ThriftHiveMetastore_get_stored_procedure_args& operator=(const ThriftHiveMetastore_get_stored_procedure_args&); + ThriftHiveMetastore_get_stored_procedure_args() noexcept; + + virtual ~ThriftHiveMetastore_get_stored_procedure_args() noexcept; + StoredProcedureRequest request; + + _ThriftHiveMetastore_get_stored_procedure_args__isset __isset; + + void __set_request(const StoredProcedureRequest& val); + + bool operator == (const ThriftHiveMetastore_get_stored_procedure_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_stored_procedure_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_stored_procedure_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_stored_procedure_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_stored_procedure_pargs() noexcept; + const StoredProcedureRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_stored_procedure_result__isset { + _ThriftHiveMetastore_get_stored_procedure_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_stored_procedure_result__isset; + +class ThriftHiveMetastore_get_stored_procedure_result { + public: + + ThriftHiveMetastore_get_stored_procedure_result(const ThriftHiveMetastore_get_stored_procedure_result&); + ThriftHiveMetastore_get_stored_procedure_result& operator=(const ThriftHiveMetastore_get_stored_procedure_result&); + ThriftHiveMetastore_get_stored_procedure_result() noexcept; + + virtual ~ThriftHiveMetastore_get_stored_procedure_result() noexcept; + StoredProcedure success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_stored_procedure_result__isset __isset; + + void __set_success(const StoredProcedure& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_get_stored_procedure_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_stored_procedure_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_stored_procedure_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_stored_procedure_presult__isset { + _ThriftHiveMetastore_get_stored_procedure_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_stored_procedure_presult__isset; + +class ThriftHiveMetastore_get_stored_procedure_presult { + public: + + + virtual ~ThriftHiveMetastore_get_stored_procedure_presult() noexcept; + StoredProcedure* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_stored_procedure_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_stored_procedure_args__isset { + _ThriftHiveMetastore_drop_stored_procedure_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_drop_stored_procedure_args__isset; + +class ThriftHiveMetastore_drop_stored_procedure_args { + public: + + ThriftHiveMetastore_drop_stored_procedure_args(const ThriftHiveMetastore_drop_stored_procedure_args&); + ThriftHiveMetastore_drop_stored_procedure_args& operator=(const ThriftHiveMetastore_drop_stored_procedure_args&); + ThriftHiveMetastore_drop_stored_procedure_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_stored_procedure_args() noexcept; + StoredProcedureRequest request; + + _ThriftHiveMetastore_drop_stored_procedure_args__isset __isset; + + void __set_request(const StoredProcedureRequest& val); + + bool operator == (const ThriftHiveMetastore_drop_stored_procedure_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_stored_procedure_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_stored_procedure_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_stored_procedure_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_stored_procedure_pargs() noexcept; + const StoredProcedureRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_stored_procedure_result__isset { + _ThriftHiveMetastore_drop_stored_procedure_result__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_drop_stored_procedure_result__isset; + +class ThriftHiveMetastore_drop_stored_procedure_result { + public: + + ThriftHiveMetastore_drop_stored_procedure_result(const ThriftHiveMetastore_drop_stored_procedure_result&); + ThriftHiveMetastore_drop_stored_procedure_result& operator=(const ThriftHiveMetastore_drop_stored_procedure_result&); + ThriftHiveMetastore_drop_stored_procedure_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_stored_procedure_result() noexcept; + MetaException o1; + + _ThriftHiveMetastore_drop_stored_procedure_result__isset __isset; + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_stored_procedure_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_stored_procedure_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_stored_procedure_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_stored_procedure_presult__isset { + _ThriftHiveMetastore_drop_stored_procedure_presult__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_drop_stored_procedure_presult__isset; + +class ThriftHiveMetastore_drop_stored_procedure_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_stored_procedure_presult() noexcept; + MetaException o1; + + _ThriftHiveMetastore_drop_stored_procedure_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_all_stored_procedures_args__isset { + _ThriftHiveMetastore_get_all_stored_procedures_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_all_stored_procedures_args__isset; + +class ThriftHiveMetastore_get_all_stored_procedures_args { + public: + + ThriftHiveMetastore_get_all_stored_procedures_args(const ThriftHiveMetastore_get_all_stored_procedures_args&); + ThriftHiveMetastore_get_all_stored_procedures_args& operator=(const ThriftHiveMetastore_get_all_stored_procedures_args&); + ThriftHiveMetastore_get_all_stored_procedures_args() noexcept; + + virtual ~ThriftHiveMetastore_get_all_stored_procedures_args() noexcept; + ListStoredProcedureRequest request; + + _ThriftHiveMetastore_get_all_stored_procedures_args__isset __isset; + + void __set_request(const ListStoredProcedureRequest& val); + + bool operator == (const ThriftHiveMetastore_get_all_stored_procedures_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_all_stored_procedures_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_all_stored_procedures_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_all_stored_procedures_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_all_stored_procedures_pargs() noexcept; + const ListStoredProcedureRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_all_stored_procedures_result__isset { + _ThriftHiveMetastore_get_all_stored_procedures_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_all_stored_procedures_result__isset; + +class ThriftHiveMetastore_get_all_stored_procedures_result { + public: + + ThriftHiveMetastore_get_all_stored_procedures_result(const ThriftHiveMetastore_get_all_stored_procedures_result&); + ThriftHiveMetastore_get_all_stored_procedures_result& operator=(const ThriftHiveMetastore_get_all_stored_procedures_result&); + ThriftHiveMetastore_get_all_stored_procedures_result() noexcept; + + virtual ~ThriftHiveMetastore_get_all_stored_procedures_result() noexcept; + std::vector success; + MetaException o1; + + _ThriftHiveMetastore_get_all_stored_procedures_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_all_stored_procedures_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_all_stored_procedures_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_all_stored_procedures_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_all_stored_procedures_presult__isset { + _ThriftHiveMetastore_get_all_stored_procedures_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_all_stored_procedures_presult__isset; + +class ThriftHiveMetastore_get_all_stored_procedures_presult { + public: + + + virtual ~ThriftHiveMetastore_get_all_stored_procedures_presult() noexcept; + std::vector * success; + MetaException o1; + + _ThriftHiveMetastore_get_all_stored_procedures_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_find_package_args__isset { + _ThriftHiveMetastore_find_package_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_find_package_args__isset; + +class ThriftHiveMetastore_find_package_args { + public: + + ThriftHiveMetastore_find_package_args(const ThriftHiveMetastore_find_package_args&); + ThriftHiveMetastore_find_package_args& operator=(const ThriftHiveMetastore_find_package_args&); + ThriftHiveMetastore_find_package_args() noexcept; + + virtual ~ThriftHiveMetastore_find_package_args() noexcept; + GetPackageRequest request; + + _ThriftHiveMetastore_find_package_args__isset __isset; + + void __set_request(const GetPackageRequest& val); + + bool operator == (const ThriftHiveMetastore_find_package_args & rhs) const; + bool operator != (const ThriftHiveMetastore_find_package_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_find_package_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_find_package_pargs { + public: + + + virtual ~ThriftHiveMetastore_find_package_pargs() noexcept; + const GetPackageRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_find_package_result__isset { + _ThriftHiveMetastore_find_package_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_find_package_result__isset; + +class ThriftHiveMetastore_find_package_result { + public: + + ThriftHiveMetastore_find_package_result(const ThriftHiveMetastore_find_package_result&); + ThriftHiveMetastore_find_package_result& operator=(const ThriftHiveMetastore_find_package_result&); + ThriftHiveMetastore_find_package_result() noexcept; + + virtual ~ThriftHiveMetastore_find_package_result() noexcept; + Package success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_find_package_result__isset __isset; + + void __set_success(const Package& val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + bool operator == (const ThriftHiveMetastore_find_package_result & rhs) const; + bool operator != (const ThriftHiveMetastore_find_package_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_find_package_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_find_package_presult__isset { + _ThriftHiveMetastore_find_package_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_find_package_presult__isset; + +class ThriftHiveMetastore_find_package_presult { + public: + + + virtual ~ThriftHiveMetastore_find_package_presult() noexcept; + Package* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_find_package_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_add_package_args__isset { + _ThriftHiveMetastore_add_package_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_add_package_args__isset; + +class ThriftHiveMetastore_add_package_args { + public: + + ThriftHiveMetastore_add_package_args(const ThriftHiveMetastore_add_package_args&); + ThriftHiveMetastore_add_package_args& operator=(const ThriftHiveMetastore_add_package_args&); + ThriftHiveMetastore_add_package_args() noexcept; + + virtual ~ThriftHiveMetastore_add_package_args() noexcept; + AddPackageRequest request; + + _ThriftHiveMetastore_add_package_args__isset __isset; + + void __set_request(const AddPackageRequest& val); + + bool operator == (const ThriftHiveMetastore_add_package_args & rhs) const; + bool operator != (const ThriftHiveMetastore_add_package_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_package_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_package_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_package_pargs() noexcept; + const AddPackageRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_package_result__isset { + _ThriftHiveMetastore_add_package_result__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_add_package_result__isset; + +class ThriftHiveMetastore_add_package_result { + public: + + ThriftHiveMetastore_add_package_result(const ThriftHiveMetastore_add_package_result&); + ThriftHiveMetastore_add_package_result& operator=(const ThriftHiveMetastore_add_package_result&); + ThriftHiveMetastore_add_package_result() noexcept; + + virtual ~ThriftHiveMetastore_add_package_result() noexcept; + MetaException o1; + + _ThriftHiveMetastore_add_package_result__isset __isset; + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_add_package_result & rhs) const; + bool operator != (const ThriftHiveMetastore_add_package_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_package_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_package_presult__isset { + _ThriftHiveMetastore_add_package_presult__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_add_package_presult__isset; + +class ThriftHiveMetastore_add_package_presult { + public: + + + virtual ~ThriftHiveMetastore_add_package_presult() noexcept; + MetaException o1; + + _ThriftHiveMetastore_add_package_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_all_packages_args__isset { + _ThriftHiveMetastore_get_all_packages_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_all_packages_args__isset; + +class ThriftHiveMetastore_get_all_packages_args { + public: + + ThriftHiveMetastore_get_all_packages_args(const ThriftHiveMetastore_get_all_packages_args&); + ThriftHiveMetastore_get_all_packages_args& operator=(const ThriftHiveMetastore_get_all_packages_args&); + ThriftHiveMetastore_get_all_packages_args() noexcept; + + virtual ~ThriftHiveMetastore_get_all_packages_args() noexcept; + ListPackageRequest request; + + _ThriftHiveMetastore_get_all_packages_args__isset __isset; + + void __set_request(const ListPackageRequest& val); + + bool operator == (const ThriftHiveMetastore_get_all_packages_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_all_packages_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_all_packages_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_all_packages_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_all_packages_pargs() noexcept; + const ListPackageRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_all_packages_result__isset { + _ThriftHiveMetastore_get_all_packages_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_all_packages_result__isset; + +class ThriftHiveMetastore_get_all_packages_result { + public: + + ThriftHiveMetastore_get_all_packages_result(const ThriftHiveMetastore_get_all_packages_result&); + ThriftHiveMetastore_get_all_packages_result& operator=(const ThriftHiveMetastore_get_all_packages_result&); + ThriftHiveMetastore_get_all_packages_result() noexcept; + + virtual ~ThriftHiveMetastore_get_all_packages_result() noexcept; + std::vector success; + MetaException o1; + + _ThriftHiveMetastore_get_all_packages_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_all_packages_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_all_packages_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_all_packages_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_all_packages_presult__isset { + _ThriftHiveMetastore_get_all_packages_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_all_packages_presult__isset; + +class ThriftHiveMetastore_get_all_packages_presult { + public: + + + virtual ~ThriftHiveMetastore_get_all_packages_presult() noexcept; + std::vector * success; + MetaException o1; + + _ThriftHiveMetastore_get_all_packages_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_package_args__isset { + _ThriftHiveMetastore_drop_package_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_drop_package_args__isset; + +class ThriftHiveMetastore_drop_package_args { + public: + + ThriftHiveMetastore_drop_package_args(const ThriftHiveMetastore_drop_package_args&); + ThriftHiveMetastore_drop_package_args& operator=(const ThriftHiveMetastore_drop_package_args&); + ThriftHiveMetastore_drop_package_args() noexcept; + + virtual ~ThriftHiveMetastore_drop_package_args() noexcept; + DropPackageRequest request; + + _ThriftHiveMetastore_drop_package_args__isset __isset; + + void __set_request(const DropPackageRequest& val); + + bool operator == (const ThriftHiveMetastore_drop_package_args & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_package_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_package_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_package_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_package_pargs() noexcept; + const DropPackageRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_package_result__isset { + _ThriftHiveMetastore_drop_package_result__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_drop_package_result__isset; + +class ThriftHiveMetastore_drop_package_result { + public: + + ThriftHiveMetastore_drop_package_result(const ThriftHiveMetastore_drop_package_result&); + ThriftHiveMetastore_drop_package_result& operator=(const ThriftHiveMetastore_drop_package_result&); + ThriftHiveMetastore_drop_package_result() noexcept; + + virtual ~ThriftHiveMetastore_drop_package_result() noexcept; + MetaException o1; + + _ThriftHiveMetastore_drop_package_result__isset __isset; + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_package_result & rhs) const; + bool operator != (const ThriftHiveMetastore_drop_package_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_package_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_package_presult__isset { + _ThriftHiveMetastore_drop_package_presult__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_drop_package_presult__isset; + +class ThriftHiveMetastore_drop_package_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_package_presult() noexcept; + MetaException o1; + + _ThriftHiveMetastore_drop_package_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_all_write_event_info_args__isset { + _ThriftHiveMetastore_get_all_write_event_info_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_all_write_event_info_args__isset; + +class ThriftHiveMetastore_get_all_write_event_info_args { + public: + + ThriftHiveMetastore_get_all_write_event_info_args(const ThriftHiveMetastore_get_all_write_event_info_args&); + ThriftHiveMetastore_get_all_write_event_info_args& operator=(const ThriftHiveMetastore_get_all_write_event_info_args&); + ThriftHiveMetastore_get_all_write_event_info_args() noexcept; + + virtual ~ThriftHiveMetastore_get_all_write_event_info_args() noexcept; + GetAllWriteEventInfoRequest request; + + _ThriftHiveMetastore_get_all_write_event_info_args__isset __isset; + + void __set_request(const GetAllWriteEventInfoRequest& val); + + bool operator == (const ThriftHiveMetastore_get_all_write_event_info_args & rhs) const; + bool operator != (const ThriftHiveMetastore_get_all_write_event_info_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_all_write_event_info_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_all_write_event_info_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_all_write_event_info_pargs() noexcept; + const GetAllWriteEventInfoRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_all_write_event_info_result__isset { + _ThriftHiveMetastore_get_all_write_event_info_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_all_write_event_info_result__isset; + +class ThriftHiveMetastore_get_all_write_event_info_result { + public: + + ThriftHiveMetastore_get_all_write_event_info_result(const ThriftHiveMetastore_get_all_write_event_info_result&); + ThriftHiveMetastore_get_all_write_event_info_result& operator=(const ThriftHiveMetastore_get_all_write_event_info_result&); + ThriftHiveMetastore_get_all_write_event_info_result() noexcept; + + virtual ~ThriftHiveMetastore_get_all_write_event_info_result() noexcept; + std::vector success; + MetaException o1; + + _ThriftHiveMetastore_get_all_write_event_info_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_all_write_event_info_result & rhs) const; + bool operator != (const ThriftHiveMetastore_get_all_write_event_info_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_all_write_event_info_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_all_write_event_info_presult__isset { + _ThriftHiveMetastore_get_all_write_event_info_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_all_write_event_info_presult__isset; + +class ThriftHiveMetastore_get_all_write_event_info_presult { + public: + + + virtual ~ThriftHiveMetastore_get_all_write_event_info_presult() noexcept; + std::vector * success; + MetaException o1; + + _ThriftHiveMetastore_get_all_write_event_info_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public ::facebook::fb303::FacebookServiceClient { + public: + ThriftHiveMetastoreClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) : + ::facebook::fb303::FacebookServiceClient(prot, prot) {} + ThriftHiveMetastoreClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) : ::facebook::fb303::FacebookServiceClient(iprot, oprot) {} + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + void abort_Compactions(AbortCompactResponse& _return, const AbortCompactionRequest& rqst) override; + void send_abort_Compactions(const AbortCompactionRequest& rqst); + void recv_abort_Compactions(AbortCompactResponse& _return); + void getMetaConf(std::string& _return, const std::string& key) override; + void send_getMetaConf(const std::string& key); + void recv_getMetaConf(std::string& _return); + void setMetaConf(const std::string& key, const std::string& value) override; + void send_setMetaConf(const std::string& key, const std::string& value); + void recv_setMetaConf(); + void create_catalog(const CreateCatalogRequest& catalog) override; + void send_create_catalog(const CreateCatalogRequest& catalog); + void recv_create_catalog(); + void alter_catalog(const AlterCatalogRequest& rqst) override; + void send_alter_catalog(const AlterCatalogRequest& rqst); + void recv_alter_catalog(); + void get_catalog(GetCatalogResponse& _return, const GetCatalogRequest& catName) override; + void send_get_catalog(const GetCatalogRequest& catName); + void recv_get_catalog(GetCatalogResponse& _return); + void get_catalogs(GetCatalogsResponse& _return) override; + void send_get_catalogs(); + void recv_get_catalogs(GetCatalogsResponse& _return); + void drop_catalog(const DropCatalogRequest& catName) override; + void send_drop_catalog(const DropCatalogRequest& catName); + void recv_drop_catalog(); + void create_database(const Database& database) override; + void send_create_database(const Database& database); + void recv_create_database(); + void create_database_req(const CreateDatabaseRequest& createDatabaseRequest) override; + void send_create_database_req(const CreateDatabaseRequest& createDatabaseRequest); + void recv_create_database_req(); + void get_database(Database& _return, const std::string& name) override; + void send_get_database(const std::string& name); + void recv_get_database(Database& _return); + void get_database_req(Database& _return, const GetDatabaseRequest& request) override; + void send_get_database_req(const GetDatabaseRequest& request); + void recv_get_database_req(Database& _return); + void drop_database(const std::string& name, const bool deleteData, const bool cascade) override; + void send_drop_database(const std::string& name, const bool deleteData, const bool cascade); + void recv_drop_database(); + void drop_database_req(const DropDatabaseRequest& req) override; + void send_drop_database_req(const DropDatabaseRequest& req); + void recv_drop_database_req(); + void get_databases(std::vector & _return, const std::string& pattern) override; + void send_get_databases(const std::string& pattern); + void recv_get_databases(std::vector & _return); + void get_all_databases(std::vector & _return) override; + void send_get_all_databases(); + void recv_get_all_databases(std::vector & _return); + void alter_database(const std::string& dbname, const Database& db) override; + void send_alter_database(const std::string& dbname, const Database& db); + void recv_alter_database(); + void alter_database_req(const AlterDatabaseRequest& alterDbReq) override; + void send_alter_database_req(const AlterDatabaseRequest& alterDbReq); + void recv_alter_database_req(); + void create_dataconnector_req(const CreateDataConnectorRequest& connectorReq) override; + void send_create_dataconnector_req(const CreateDataConnectorRequest& connectorReq); + void recv_create_dataconnector_req(); + void get_dataconnector_req(DataConnector& _return, const GetDataConnectorRequest& request) override; + void send_get_dataconnector_req(const GetDataConnectorRequest& request); + void recv_get_dataconnector_req(DataConnector& _return); + void drop_dataconnector_req(const DropDataConnectorRequest& dropDcReq) override; + void send_drop_dataconnector_req(const DropDataConnectorRequest& dropDcReq); + void recv_drop_dataconnector_req(); + void get_dataconnectors(std::vector & _return) override; + void send_get_dataconnectors(); + void recv_get_dataconnectors(std::vector & _return); + void alter_dataconnector_req(const AlterDataConnectorRequest& alterReq) override; + void send_alter_dataconnector_req(const AlterDataConnectorRequest& alterReq); + void recv_alter_dataconnector_req(); + void get_type(Type& _return, const std::string& name) override; + void send_get_type(const std::string& name); + void recv_get_type(Type& _return); + bool create_type(const Type& type) override; + void send_create_type(const Type& type); + bool recv_create_type(); + bool drop_type(const std::string& type) override; + void send_drop_type(const std::string& type); + bool recv_drop_type(); + void get_type_all(std::map & _return, const std::string& name) override; + void send_get_type_all(const std::string& name); + void recv_get_type_all(std::map & _return); + void get_fields(std::vector & _return, const std::string& db_name, const std::string& table_name) override; + void send_get_fields(const std::string& db_name, const std::string& table_name); + void recv_get_fields(std::vector & _return); + void get_fields_with_environment_context(std::vector & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) override; + void send_get_fields_with_environment_context(const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context); + void recv_get_fields_with_environment_context(std::vector & _return); + void get_fields_req(GetFieldsResponse& _return, const GetFieldsRequest& req) override; + void send_get_fields_req(const GetFieldsRequest& req); + void recv_get_fields_req(GetFieldsResponse& _return); + void get_schema(std::vector & _return, const std::string& db_name, const std::string& table_name) override; + void send_get_schema(const std::string& db_name, const std::string& table_name); + void recv_get_schema(std::vector & _return); + void get_schema_with_environment_context(std::vector & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) override; + void send_get_schema_with_environment_context(const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context); + void recv_get_schema_with_environment_context(std::vector & _return); + void get_schema_req(GetSchemaResponse& _return, const GetSchemaRequest& req) override; + void send_get_schema_req(const GetSchemaRequest& req); + void recv_get_schema_req(GetSchemaResponse& _return); + void create_table(const Table& tbl) override; + void send_create_table(const Table& tbl); + void recv_create_table(); + void create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context) override; + void send_create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context); + void recv_create_table_with_environment_context(); + void create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys, const std::vector & uniqueConstraints, const std::vector & notNullConstraints, const std::vector & defaultConstraints, const std::vector & checkConstraints) override; + void send_create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys, const std::vector & uniqueConstraints, const std::vector & notNullConstraints, const std::vector & defaultConstraints, const std::vector & checkConstraints); + void recv_create_table_with_constraints(); + void create_table_req(const CreateTableRequest& request) override; + void send_create_table_req(const CreateTableRequest& request); + void recv_create_table_req(); + void drop_constraint(const DropConstraintRequest& req) override; + void send_drop_constraint(const DropConstraintRequest& req); + void recv_drop_constraint(); + void add_primary_key(const AddPrimaryKeyRequest& req) override; + void send_add_primary_key(const AddPrimaryKeyRequest& req); + void recv_add_primary_key(); + void add_foreign_key(const AddForeignKeyRequest& req) override; + void send_add_foreign_key(const AddForeignKeyRequest& req); + void recv_add_foreign_key(); + void add_unique_constraint(const AddUniqueConstraintRequest& req) override; + void send_add_unique_constraint(const AddUniqueConstraintRequest& req); + void recv_add_unique_constraint(); + void add_not_null_constraint(const AddNotNullConstraintRequest& req) override; + void send_add_not_null_constraint(const AddNotNullConstraintRequest& req); + void recv_add_not_null_constraint(); + void add_default_constraint(const AddDefaultConstraintRequest& req) override; + void send_add_default_constraint(const AddDefaultConstraintRequest& req); + void recv_add_default_constraint(); + void add_check_constraint(const AddCheckConstraintRequest& req) override; + void send_add_check_constraint(const AddCheckConstraintRequest& req); + void recv_add_check_constraint(); + void translate_table_dryrun(Table& _return, const CreateTableRequest& request) override; + void send_translate_table_dryrun(const CreateTableRequest& request); + void recv_translate_table_dryrun(Table& _return); + void drop_table(const std::string& dbname, const std::string& name, const bool deleteData) override; + void send_drop_table(const std::string& dbname, const std::string& name, const bool deleteData); + void recv_drop_table(); + void drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context) override; + void send_drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context); + void recv_drop_table_with_environment_context(); + void drop_table_req(const DropTableRequest& dropTableReq) override; + void send_drop_table_req(const DropTableRequest& dropTableReq); + void recv_drop_table_req(); + void truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames) override; + void send_truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames); + void recv_truncate_table(); + void truncate_table_req(TruncateTableResponse& _return, const TruncateTableRequest& req) override; + void send_truncate_table_req(const TruncateTableRequest& req); + void recv_truncate_table_req(TruncateTableResponse& _return); + void get_tables(std::vector & _return, const std::string& db_name, const std::string& pattern) override; + void send_get_tables(const std::string& db_name, const std::string& pattern); + void recv_get_tables(std::vector & _return); + void get_tables_by_type(std::vector & _return, const std::string& db_name, const std::string& pattern, const std::string& tableType) override; + void send_get_tables_by_type(const std::string& db_name, const std::string& pattern, const std::string& tableType); + void recv_get_tables_by_type(std::vector & _return); + void get_all_materialized_view_objects_for_rewriting(std::vector
& _return) override; + void send_get_all_materialized_view_objects_for_rewriting(); + void recv_get_all_materialized_view_objects_for_rewriting(std::vector
& _return); + void get_materialized_views_for_rewriting(std::vector & _return, const std::string& db_name) override; + void send_get_materialized_views_for_rewriting(const std::string& db_name); + void recv_get_materialized_views_for_rewriting(std::vector & _return); + void get_table_meta(std::vector & _return, const std::string& db_patterns, const std::string& tbl_patterns, const std::vector & tbl_types) override; + void send_get_table_meta(const std::string& db_patterns, const std::string& tbl_patterns, const std::vector & tbl_types); + void recv_get_table_meta(std::vector & _return); + void get_all_tables(std::vector & _return, const std::string& db_name) override; + void send_get_all_tables(const std::string& db_name); + void recv_get_all_tables(std::vector & _return); + void get_tables_ext(std::vector & _return, const GetTablesExtRequest& req) override; + void send_get_tables_ext(const GetTablesExtRequest& req); + void recv_get_tables_ext(std::vector & _return); + void get_table_req(GetTableResult& _return, const GetTableRequest& req) override; + void send_get_table_req(const GetTableRequest& req); + void recv_get_table_req(GetTableResult& _return); + void get_table_objects_by_name_req(GetTablesResult& _return, const GetTablesRequest& req) override; + void send_get_table_objects_by_name_req(const GetTablesRequest& req); + void recv_get_table_objects_by_name_req(GetTablesResult& _return); + void get_materialization_invalidation_info(Materialization& _return, const CreationMetadata& creation_metadata, const std::string& validTxnList) override; + void send_get_materialization_invalidation_info(const CreationMetadata& creation_metadata, const std::string& validTxnList); + void recv_get_materialization_invalidation_info(Materialization& _return); + void update_creation_metadata(const std::string& catName, const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata) override; + void send_update_creation_metadata(const std::string& catName, const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata); + void recv_update_creation_metadata(); + void get_table_names_by_filter(std::vector & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables) override; + void send_get_table_names_by_filter(const std::string& dbname, const std::string& filter, const int16_t max_tables); + void recv_get_table_names_by_filter(std::vector & _return); + void alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl) override; + void send_alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl); + void recv_alter_table(); + void alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context) override; + void send_alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context); + void recv_alter_table_with_environment_context(); + void alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade) override; + void send_alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade); + void recv_alter_table_with_cascade(); + void alter_table_req(AlterTableResponse& _return, const AlterTableRequest& req) override; + void send_alter_table_req(const AlterTableRequest& req); + void recv_alter_table_req(AlterTableResponse& _return); + void add_partition(Partition& _return, const Partition& new_part) override; + void send_add_partition(const Partition& new_part); + void recv_add_partition(Partition& _return); + void add_partition_with_environment_context(Partition& _return, const Partition& new_part, const EnvironmentContext& environment_context) override; + void send_add_partition_with_environment_context(const Partition& new_part, const EnvironmentContext& environment_context); + void recv_add_partition_with_environment_context(Partition& _return); + int32_t add_partitions(const std::vector & new_parts) override; + void send_add_partitions(const std::vector & new_parts); + int32_t recv_add_partitions(); + int32_t add_partitions_pspec(const std::vector & new_parts) override; + void send_add_partitions_pspec(const std::vector & new_parts); + int32_t recv_add_partitions_pspec(); + void append_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals) override; + void send_append_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals); + void recv_append_partition(Partition& _return); + void add_partitions_req(AddPartitionsResult& _return, const AddPartitionsRequest& request) override; + void send_add_partitions_req(const AddPartitionsRequest& request); + void recv_add_partitions_req(AddPartitionsResult& _return); + void append_partition_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const EnvironmentContext& environment_context) override; + void send_append_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const EnvironmentContext& environment_context); + void recv_append_partition_with_environment_context(Partition& _return); + void append_partition_req(Partition& _return, const AppendPartitionsRequest& appendPartitionsReq) override; + void send_append_partition_req(const AppendPartitionsRequest& appendPartitionsReq); + void recv_append_partition_req(Partition& _return); + void append_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name) override; + void send_append_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name); + void recv_append_partition_by_name(Partition& _return); + void append_partition_by_name_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context) override; + void send_append_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context); + void recv_append_partition_by_name_with_environment_context(Partition& _return); + bool drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData) override; + void send_drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData); + bool recv_drop_partition(); + bool drop_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData, const EnvironmentContext& environment_context) override; + void send_drop_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData, const EnvironmentContext& environment_context); + bool recv_drop_partition_with_environment_context(); + bool drop_partition_req(const DropPartitionRequest& dropPartitionReq) override; + void send_drop_partition_req(const DropPartitionRequest& dropPartitionReq); + bool recv_drop_partition_req(); + bool drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData) override; + void send_drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData); + bool recv_drop_partition_by_name(); + bool drop_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData, const EnvironmentContext& environment_context) override; + void send_drop_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData, const EnvironmentContext& environment_context); + bool recv_drop_partition_by_name_with_environment_context(); + void drop_partitions_req(DropPartitionsResult& _return, const DropPartitionsRequest& req) override; + void send_drop_partitions_req(const DropPartitionsRequest& req); + void recv_drop_partitions_req(DropPartitionsResult& _return); + void get_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals) override; + void send_get_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals); + void recv_get_partition(Partition& _return); + void get_partition_req(GetPartitionResponse& _return, const GetPartitionRequest& req) override; + void send_get_partition_req(const GetPartitionRequest& req); + void recv_get_partition_req(GetPartitionResponse& _return); + void exchange_partition(Partition& _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) override; + void send_exchange_partition(const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name); + void recv_exchange_partition(Partition& _return); + void exchange_partitions(std::vector & _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) override; + void send_exchange_partitions(const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name); + void recv_exchange_partitions(std::vector & _return); + void get_partition_with_auth(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const std::string& user_name, const std::vector & group_names) override; + void send_get_partition_with_auth(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const std::string& user_name, const std::vector & group_names); + void recv_get_partition_with_auth(Partition& _return); + void get_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name) override; + void send_get_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name); + void recv_get_partition_by_name(Partition& _return); + void get_partitions(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts) override; + void send_get_partitions(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts); + void recv_get_partitions(std::vector & _return); + void get_partitions_req(PartitionsResponse& _return, const PartitionsRequest& req) override; + void send_get_partitions_req(const PartitionsRequest& req); + void recv_get_partitions_req(PartitionsResponse& _return); + void get_partitions_with_auth(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts, const std::string& user_name, const std::vector & group_names) override; + void send_get_partitions_with_auth(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts, const std::string& user_name, const std::vector & group_names); + void recv_get_partitions_with_auth(std::vector & _return); + void get_partitions_pspec(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int32_t max_parts) override; + void send_get_partitions_pspec(const std::string& db_name, const std::string& tbl_name, const int32_t max_parts); + void recv_get_partitions_pspec(std::vector & _return); + void get_partition_names(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts) override; + void send_get_partition_names(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts); + void recv_get_partition_names(std::vector & _return); + void fetch_partition_names_req(std::vector & _return, const PartitionsRequest& partitionReq) override; + void send_fetch_partition_names_req(const PartitionsRequest& partitionReq); + void recv_fetch_partition_names_req(std::vector & _return); + void get_partition_values(PartitionValuesResponse& _return, const PartitionValuesRequest& request) override; + void send_get_partition_values(const PartitionValuesRequest& request); + void recv_get_partition_values(PartitionValuesResponse& _return); + void get_partitions_ps(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts) override; + void send_get_partitions_ps(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts); + void recv_get_partitions_ps(std::vector & _return); + void get_partitions_ps_with_auth(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts, const std::string& user_name, const std::vector & group_names) override; + void send_get_partitions_ps_with_auth(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts, const std::string& user_name, const std::vector & group_names); + void recv_get_partitions_ps_with_auth(std::vector & _return); + void get_partitions_ps_with_auth_req(GetPartitionsPsWithAuthResponse& _return, const GetPartitionsPsWithAuthRequest& req) override; + void send_get_partitions_ps_with_auth_req(const GetPartitionsPsWithAuthRequest& req); + void recv_get_partitions_ps_with_auth_req(GetPartitionsPsWithAuthResponse& _return); + void get_partition_names_ps(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts) override; + void send_get_partition_names_ps(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts); + void recv_get_partition_names_ps(std::vector & _return); + void get_partition_names_ps_req(GetPartitionNamesPsResponse& _return, const GetPartitionNamesPsRequest& req) override; + void send_get_partition_names_ps_req(const GetPartitionNamesPsRequest& req); + void recv_get_partition_names_ps_req(GetPartitionNamesPsResponse& _return); + void get_partition_names_req(std::vector & _return, const PartitionsByExprRequest& req) override; + void send_get_partition_names_req(const PartitionsByExprRequest& req); + void recv_get_partition_names_req(std::vector & _return); + void get_partitions_by_filter(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int16_t max_parts) override; + void send_get_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int16_t max_parts); + void recv_get_partitions_by_filter(std::vector & _return); + void get_partitions_by_filter_req(std::vector & _return, const GetPartitionsByFilterRequest& req) override; + void send_get_partitions_by_filter_req(const GetPartitionsByFilterRequest& req); + void recv_get_partitions_by_filter_req(std::vector & _return); + void get_part_specs_by_filter(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int32_t max_parts) override; + void send_get_part_specs_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int32_t max_parts); + void recv_get_part_specs_by_filter(std::vector & _return); + void get_partitions_by_expr(PartitionsByExprResult& _return, const PartitionsByExprRequest& req) override; + void send_get_partitions_by_expr(const PartitionsByExprRequest& req); + void recv_get_partitions_by_expr(PartitionsByExprResult& _return); + void get_partitions_spec_by_expr(PartitionsSpecByExprResult& _return, const PartitionsByExprRequest& req) override; + void send_get_partitions_spec_by_expr(const PartitionsByExprRequest& req); + void recv_get_partitions_spec_by_expr(PartitionsSpecByExprResult& _return); + int32_t get_num_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter) override; + void send_get_num_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter); + int32_t recv_get_num_partitions_by_filter(); + void get_partitions_by_names(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & names) override; + void send_get_partitions_by_names(const std::string& db_name, const std::string& tbl_name, const std::vector & names); + void recv_get_partitions_by_names(std::vector & _return); + void get_partitions_by_names_req(GetPartitionsByNamesResult& _return, const GetPartitionsByNamesRequest& req) override; + void send_get_partitions_by_names_req(const GetPartitionsByNamesRequest& req); + void recv_get_partitions_by_names_req(GetPartitionsByNamesResult& _return); + void get_properties(PropertyGetResponse& _return, const PropertyGetRequest& req) override; + void send_get_properties(const PropertyGetRequest& req); + void recv_get_properties(PropertyGetResponse& _return); + bool set_properties(const PropertySetRequest& req) override; + void send_set_properties(const PropertySetRequest& req); + bool recv_set_properties(); + void alter_partition(const std::string& db_name, const std::string& tbl_name, const Partition& new_part) override; + void send_alter_partition(const std::string& db_name, const std::string& tbl_name, const Partition& new_part); + void recv_alter_partition(); + void alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts) override; + void send_alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts); + void recv_alter_partitions(); + void alter_partitions_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts, const EnvironmentContext& environment_context) override; + void send_alter_partitions_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts, const EnvironmentContext& environment_context); + void recv_alter_partitions_with_environment_context(); + void alter_partitions_req(AlterPartitionsResponse& _return, const AlterPartitionsRequest& req) override; + void send_alter_partitions_req(const AlterPartitionsRequest& req); + void recv_alter_partitions_req(AlterPartitionsResponse& _return); + void alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context) override; + void send_alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context); + void recv_alter_partition_with_environment_context(); + void rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const Partition& new_part) override; + void send_rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const Partition& new_part); + void recv_rename_partition(); + void rename_partition_req(RenamePartitionResponse& _return, const RenamePartitionRequest& req) override; + void send_rename_partition_req(const RenamePartitionRequest& req); + void recv_rename_partition_req(RenamePartitionResponse& _return); + bool partition_name_has_valid_characters(const std::vector & part_vals, const bool throw_exception) override; + void send_partition_name_has_valid_characters(const std::vector & part_vals, const bool throw_exception); + bool recv_partition_name_has_valid_characters(); + void get_config_value(std::string& _return, const std::string& name, const std::string& defaultValue) override; + void send_get_config_value(const std::string& name, const std::string& defaultValue); + void recv_get_config_value(std::string& _return); + void partition_name_to_vals(std::vector & _return, const std::string& part_name) override; + void send_partition_name_to_vals(const std::string& part_name); + void recv_partition_name_to_vals(std::vector & _return); + void partition_name_to_spec(std::map & _return, const std::string& part_name) override; + void send_partition_name_to_spec(const std::string& part_name); + void recv_partition_name_to_spec(std::map & _return); + void markPartitionForEvent(const std::string& db_name, const std::string& tbl_name, const std::map & part_vals, const PartitionEventType::type eventType) override; + void send_markPartitionForEvent(const std::string& db_name, const std::string& tbl_name, const std::map & part_vals, const PartitionEventType::type eventType); + void recv_markPartitionForEvent(); + bool isPartitionMarkedForEvent(const std::string& db_name, const std::string& tbl_name, const std::map & part_vals, const PartitionEventType::type eventType) override; + void send_isPartitionMarkedForEvent(const std::string& db_name, const std::string& tbl_name, const std::map & part_vals, const PartitionEventType::type eventType); + bool recv_isPartitionMarkedForEvent(); + void get_primary_keys(PrimaryKeysResponse& _return, const PrimaryKeysRequest& request) override; + void send_get_primary_keys(const PrimaryKeysRequest& request); + void recv_get_primary_keys(PrimaryKeysResponse& _return); + void get_foreign_keys(ForeignKeysResponse& _return, const ForeignKeysRequest& request) override; + void send_get_foreign_keys(const ForeignKeysRequest& request); + void recv_get_foreign_keys(ForeignKeysResponse& _return); + void get_unique_constraints(UniqueConstraintsResponse& _return, const UniqueConstraintsRequest& request) override; + void send_get_unique_constraints(const UniqueConstraintsRequest& request); + void recv_get_unique_constraints(UniqueConstraintsResponse& _return); + void get_not_null_constraints(NotNullConstraintsResponse& _return, const NotNullConstraintsRequest& request) override; + void send_get_not_null_constraints(const NotNullConstraintsRequest& request); + void recv_get_not_null_constraints(NotNullConstraintsResponse& _return); + void get_default_constraints(DefaultConstraintsResponse& _return, const DefaultConstraintsRequest& request) override; + void send_get_default_constraints(const DefaultConstraintsRequest& request); + void recv_get_default_constraints(DefaultConstraintsResponse& _return); + void get_check_constraints(CheckConstraintsResponse& _return, const CheckConstraintsRequest& request) override; + void send_get_check_constraints(const CheckConstraintsRequest& request); + void recv_get_check_constraints(CheckConstraintsResponse& _return); + void get_all_table_constraints(AllTableConstraintsResponse& _return, const AllTableConstraintsRequest& request) override; + void send_get_all_table_constraints(const AllTableConstraintsRequest& request); + void recv_get_all_table_constraints(AllTableConstraintsResponse& _return); + bool update_table_column_statistics(const ColumnStatistics& stats_obj) override; + void send_update_table_column_statistics(const ColumnStatistics& stats_obj); + bool recv_update_table_column_statistics(); + bool update_partition_column_statistics(const ColumnStatistics& stats_obj) override; + void send_update_partition_column_statistics(const ColumnStatistics& stats_obj); + bool recv_update_partition_column_statistics(); + void update_table_column_statistics_req(SetPartitionsStatsResponse& _return, const SetPartitionsStatsRequest& req) override; + void send_update_table_column_statistics_req(const SetPartitionsStatsRequest& req); + void recv_update_table_column_statistics_req(SetPartitionsStatsResponse& _return); + void update_partition_column_statistics_req(SetPartitionsStatsResponse& _return, const SetPartitionsStatsRequest& req) override; + void send_update_partition_column_statistics_req(const SetPartitionsStatsRequest& req); + void recv_update_partition_column_statistics_req(SetPartitionsStatsResponse& _return); + void update_transaction_statistics(const UpdateTransactionalStatsRequest& req) override; + void send_update_transaction_statistics(const UpdateTransactionalStatsRequest& req); + void recv_update_transaction_statistics(); + void get_table_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& col_name) override; + void send_get_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name); + void recv_get_table_column_statistics(ColumnStatistics& _return); + void get_partition_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name) override; + void send_get_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name); + void recv_get_partition_column_statistics(ColumnStatistics& _return); + void get_table_statistics_req(TableStatsResult& _return, const TableStatsRequest& request) override; + void send_get_table_statistics_req(const TableStatsRequest& request); + void recv_get_table_statistics_req(TableStatsResult& _return); + void get_partitions_statistics_req(PartitionsStatsResult& _return, const PartitionsStatsRequest& request) override; + void send_get_partitions_statistics_req(const PartitionsStatsRequest& request); + void recv_get_partitions_statistics_req(PartitionsStatsResult& _return); + void get_aggr_stats_for(AggrStats& _return, const PartitionsStatsRequest& request) override; + void send_get_aggr_stats_for(const PartitionsStatsRequest& request); + void recv_get_aggr_stats_for(AggrStats& _return); + bool set_aggr_stats_for(const SetPartitionsStatsRequest& request) override; + void send_set_aggr_stats_for(const SetPartitionsStatsRequest& request); + bool recv_set_aggr_stats_for(); + bool delete_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name, const std::string& engine) override; + void send_delete_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name, const std::string& engine); + bool recv_delete_partition_column_statistics(); + bool delete_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name, const std::string& engine) override; + void send_delete_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name, const std::string& engine); + bool recv_delete_table_column_statistics(); + void create_function(const Function& func) override; + void send_create_function(const Function& func); + void recv_create_function(); + void drop_function(const std::string& dbName, const std::string& funcName) override; + void send_drop_function(const std::string& dbName, const std::string& funcName); + void recv_drop_function(); + void alter_function(const std::string& dbName, const std::string& funcName, const Function& newFunc) override; + void send_alter_function(const std::string& dbName, const std::string& funcName, const Function& newFunc); + void recv_alter_function(); + void get_functions(std::vector & _return, const std::string& dbName, const std::string& pattern) override; + void send_get_functions(const std::string& dbName, const std::string& pattern); + void recv_get_functions(std::vector & _return); + void get_function(Function& _return, const std::string& dbName, const std::string& funcName) override; + void send_get_function(const std::string& dbName, const std::string& funcName); + void recv_get_function(Function& _return); + void get_all_functions(GetAllFunctionsResponse& _return) override; + void send_get_all_functions(); + void recv_get_all_functions(GetAllFunctionsResponse& _return); + bool create_role(const Role& role) override; + void send_create_role(const Role& role); + bool recv_create_role(); + bool drop_role(const std::string& role_name) override; + void send_drop_role(const std::string& role_name); + bool recv_drop_role(); + void get_role_names(std::vector & _return) override; + void send_get_role_names(); + void recv_get_role_names(std::vector & _return); + bool grant_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type, const std::string& grantor, const PrincipalType::type grantorType, const bool grant_option) override; + void send_grant_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type, const std::string& grantor, const PrincipalType::type grantorType, const bool grant_option); + bool recv_grant_role(); + bool revoke_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type) override; + void send_revoke_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type); + bool recv_revoke_role(); + void list_roles(std::vector & _return, const std::string& principal_name, const PrincipalType::type principal_type) override; + void send_list_roles(const std::string& principal_name, const PrincipalType::type principal_type); + void recv_list_roles(std::vector & _return); + void grant_revoke_role(GrantRevokeRoleResponse& _return, const GrantRevokeRoleRequest& request) override; + void send_grant_revoke_role(const GrantRevokeRoleRequest& request); + void recv_grant_revoke_role(GrantRevokeRoleResponse& _return); + void get_principals_in_role(GetPrincipalsInRoleResponse& _return, const GetPrincipalsInRoleRequest& request) override; + void send_get_principals_in_role(const GetPrincipalsInRoleRequest& request); + void recv_get_principals_in_role(GetPrincipalsInRoleResponse& _return); + void get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& _return, const GetRoleGrantsForPrincipalRequest& request) override; + void send_get_role_grants_for_principal(const GetRoleGrantsForPrincipalRequest& request); + void recv_get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& _return); + void get_privilege_set(PrincipalPrivilegeSet& _return, const HiveObjectRef& hiveObject, const std::string& user_name, const std::vector & group_names) override; + void send_get_privilege_set(const HiveObjectRef& hiveObject, const std::string& user_name, const std::vector & group_names); + void recv_get_privilege_set(PrincipalPrivilegeSet& _return); + void list_privileges(std::vector & _return, const std::string& principal_name, const PrincipalType::type principal_type, const HiveObjectRef& hiveObject) override; + void send_list_privileges(const std::string& principal_name, const PrincipalType::type principal_type, const HiveObjectRef& hiveObject); + void recv_list_privileges(std::vector & _return); + bool grant_privileges(const PrivilegeBag& privileges) override; + void send_grant_privileges(const PrivilegeBag& privileges); + bool recv_grant_privileges(); + bool revoke_privileges(const PrivilegeBag& privileges) override; + void send_revoke_privileges(const PrivilegeBag& privileges); + bool recv_revoke_privileges(); + void grant_revoke_privileges(GrantRevokePrivilegeResponse& _return, const GrantRevokePrivilegeRequest& request) override; + void send_grant_revoke_privileges(const GrantRevokePrivilegeRequest& request); + void recv_grant_revoke_privileges(GrantRevokePrivilegeResponse& _return); + void refresh_privileges(GrantRevokePrivilegeResponse& _return, const HiveObjectRef& objToRefresh, const std::string& authorizer, const GrantRevokePrivilegeRequest& grantRequest) override; + void send_refresh_privileges(const HiveObjectRef& objToRefresh, const std::string& authorizer, const GrantRevokePrivilegeRequest& grantRequest); + void recv_refresh_privileges(GrantRevokePrivilegeResponse& _return); + void set_ugi(std::vector & _return, const std::string& user_name, const std::vector & group_names) override; + void send_set_ugi(const std::string& user_name, const std::vector & group_names); + void recv_set_ugi(std::vector & _return); + void get_delegation_token(std::string& _return, const std::string& token_owner, const std::string& renewer_kerberos_principal_name) override; + void send_get_delegation_token(const std::string& token_owner, const std::string& renewer_kerberos_principal_name); + void recv_get_delegation_token(std::string& _return); + int64_t renew_delegation_token(const std::string& token_str_form) override; + void send_renew_delegation_token(const std::string& token_str_form); + int64_t recv_renew_delegation_token(); + void cancel_delegation_token(const std::string& token_str_form) override; + void send_cancel_delegation_token(const std::string& token_str_form); + void recv_cancel_delegation_token(); + bool add_token(const std::string& token_identifier, const std::string& delegation_token) override; + void send_add_token(const std::string& token_identifier, const std::string& delegation_token); + bool recv_add_token(); + bool remove_token(const std::string& token_identifier) override; + void send_remove_token(const std::string& token_identifier); + bool recv_remove_token(); + void get_token(std::string& _return, const std::string& token_identifier) override; + void send_get_token(const std::string& token_identifier); + void recv_get_token(std::string& _return); + void get_all_token_identifiers(std::vector & _return) override; + void send_get_all_token_identifiers(); + void recv_get_all_token_identifiers(std::vector & _return); + int32_t add_master_key(const std::string& key) override; + void send_add_master_key(const std::string& key); + int32_t recv_add_master_key(); + void update_master_key(const int32_t seq_number, const std::string& key) override; + void send_update_master_key(const int32_t seq_number, const std::string& key); + void recv_update_master_key(); + bool remove_master_key(const int32_t key_seq) override; + void send_remove_master_key(const int32_t key_seq); + bool recv_remove_master_key(); + void get_master_keys(std::vector & _return) override; + void send_get_master_keys(); + void recv_get_master_keys(std::vector & _return); + void get_open_txns(GetOpenTxnsResponse& _return) override; + void send_get_open_txns(); + void recv_get_open_txns(GetOpenTxnsResponse& _return); + void get_open_txns_info(GetOpenTxnsInfoResponse& _return) override; + void send_get_open_txns_info(); + void recv_get_open_txns_info(GetOpenTxnsInfoResponse& _return); + void open_txns(OpenTxnsResponse& _return, const OpenTxnRequest& rqst) override; + void send_open_txns(const OpenTxnRequest& rqst); + void recv_open_txns(OpenTxnsResponse& _return); + void abort_txn(const AbortTxnRequest& rqst) override; + void send_abort_txn(const AbortTxnRequest& rqst); + void recv_abort_txn(); + void abort_txns(const AbortTxnsRequest& rqst) override; + void send_abort_txns(const AbortTxnsRequest& rqst); + void recv_abort_txns(); + void commit_txn(const CommitTxnRequest& rqst) override; + void send_commit_txn(const CommitTxnRequest& rqst); + void recv_commit_txn(); + int64_t get_latest_txnid_in_conflict(const int64_t txnId) override; + void send_get_latest_txnid_in_conflict(const int64_t txnId); + int64_t recv_get_latest_txnid_in_conflict(); + void repl_tbl_writeid_state(const ReplTblWriteIdStateRequest& rqst) override; + void send_repl_tbl_writeid_state(const ReplTblWriteIdStateRequest& rqst); + void recv_repl_tbl_writeid_state(); + void get_valid_write_ids(GetValidWriteIdsResponse& _return, const GetValidWriteIdsRequest& rqst) override; + void send_get_valid_write_ids(const GetValidWriteIdsRequest& rqst); + void recv_get_valid_write_ids(GetValidWriteIdsResponse& _return); + void add_write_ids_to_min_history(const int64_t txnId, const std::map & writeIds) override; + void send_add_write_ids_to_min_history(const int64_t txnId, const std::map & writeIds); + void recv_add_write_ids_to_min_history(); + void allocate_table_write_ids(AllocateTableWriteIdsResponse& _return, const AllocateTableWriteIdsRequest& rqst) override; + void send_allocate_table_write_ids(const AllocateTableWriteIdsRequest& rqst); + void recv_allocate_table_write_ids(AllocateTableWriteIdsResponse& _return); + void get_max_allocated_table_write_id(MaxAllocatedTableWriteIdResponse& _return, const MaxAllocatedTableWriteIdRequest& rqst) override; + void send_get_max_allocated_table_write_id(const MaxAllocatedTableWriteIdRequest& rqst); + void recv_get_max_allocated_table_write_id(MaxAllocatedTableWriteIdResponse& _return); + void seed_write_id(const SeedTableWriteIdsRequest& rqst) override; + void send_seed_write_id(const SeedTableWriteIdsRequest& rqst); + void recv_seed_write_id(); + void seed_txn_id(const SeedTxnIdRequest& rqst) override; + void send_seed_txn_id(const SeedTxnIdRequest& rqst); + void recv_seed_txn_id(); + void lock(LockResponse& _return, const LockRequest& rqst) override; + void send_lock(const LockRequest& rqst); + void recv_lock(LockResponse& _return); + void check_lock(LockResponse& _return, const CheckLockRequest& rqst) override; + void send_check_lock(const CheckLockRequest& rqst); + void recv_check_lock(LockResponse& _return); + void unlock(const UnlockRequest& rqst) override; + void send_unlock(const UnlockRequest& rqst); + void recv_unlock(); + void show_locks(ShowLocksResponse& _return, const ShowLocksRequest& rqst) override; + void send_show_locks(const ShowLocksRequest& rqst); + void recv_show_locks(ShowLocksResponse& _return); + void heartbeat(const HeartbeatRequest& ids) override; + void send_heartbeat(const HeartbeatRequest& ids); + void recv_heartbeat(); + void heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const HeartbeatTxnRangeRequest& txns) override; + void send_heartbeat_txn_range(const HeartbeatTxnRangeRequest& txns); + void recv_heartbeat_txn_range(HeartbeatTxnRangeResponse& _return); + void compact(const CompactionRequest& rqst) override; + void send_compact(const CompactionRequest& rqst); + void recv_compact(); + void compact2(CompactionResponse& _return, const CompactionRequest& rqst) override; + void send_compact2(const CompactionRequest& rqst); + void recv_compact2(CompactionResponse& _return); + void show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst) override; + void send_show_compact(const ShowCompactRequest& rqst); + void recv_show_compact(ShowCompactResponse& _return); + bool submit_for_cleanup(const CompactionRequest& o1, const int64_t o2, const int64_t o3) override; + void send_submit_for_cleanup(const CompactionRequest& o1, const int64_t o2, const int64_t o3); + bool recv_submit_for_cleanup(); + void add_dynamic_partitions(const AddDynamicPartitions& rqst) override; + void send_add_dynamic_partitions(const AddDynamicPartitions& rqst); + void recv_add_dynamic_partitions(); + void find_next_compact(OptionalCompactionInfoStruct& _return, const std::string& workerId) override; + void send_find_next_compact(const std::string& workerId); + void recv_find_next_compact(OptionalCompactionInfoStruct& _return); + void find_next_compact2(OptionalCompactionInfoStruct& _return, const FindNextCompactRequest& rqst) override; + void send_find_next_compact2(const FindNextCompactRequest& rqst); + void recv_find_next_compact2(OptionalCompactionInfoStruct& _return); + void update_compactor_state(const CompactionInfoStruct& cr, const int64_t txn_id) override; + void send_update_compactor_state(const CompactionInfoStruct& cr, const int64_t txn_id); + void recv_update_compactor_state(); + void find_columns_with_stats(std::vector & _return, const CompactionInfoStruct& cr) override; + void send_find_columns_with_stats(const CompactionInfoStruct& cr); + void recv_find_columns_with_stats(std::vector & _return); + void mark_cleaned(const CompactionInfoStruct& cr) override; + void send_mark_cleaned(const CompactionInfoStruct& cr); + void recv_mark_cleaned(); + void mark_compacted(const CompactionInfoStruct& cr) override; + void send_mark_compacted(const CompactionInfoStruct& cr); + void recv_mark_compacted(); + void mark_failed(const CompactionInfoStruct& cr) override; + void send_mark_failed(const CompactionInfoStruct& cr); + void recv_mark_failed(); + void mark_refused(const CompactionInfoStruct& cr) override; + void send_mark_refused(const CompactionInfoStruct& cr); + void recv_mark_refused(); + bool update_compaction_metrics_data(const CompactionMetricsDataStruct& data) override; + void send_update_compaction_metrics_data(const CompactionMetricsDataStruct& data); + bool recv_update_compaction_metrics_data(); + void remove_compaction_metrics_data(const CompactionMetricsDataRequest& request) override; + void send_remove_compaction_metrics_data(const CompactionMetricsDataRequest& request); + void recv_remove_compaction_metrics_data(); + void set_hadoop_jobid(const std::string& jobId, const int64_t cq_id) override; + void send_set_hadoop_jobid(const std::string& jobId, const int64_t cq_id); + void recv_set_hadoop_jobid(); + void get_latest_committed_compaction_info(GetLatestCommittedCompactionInfoResponse& _return, const GetLatestCommittedCompactionInfoRequest& rqst) override; + void send_get_latest_committed_compaction_info(const GetLatestCommittedCompactionInfoRequest& rqst); + void recv_get_latest_committed_compaction_info(GetLatestCommittedCompactionInfoResponse& _return); + void get_next_notification(NotificationEventResponse& _return, const NotificationEventRequest& rqst) override; + void send_get_next_notification(const NotificationEventRequest& rqst); + void recv_get_next_notification(NotificationEventResponse& _return); + void get_current_notificationEventId(CurrentNotificationEventId& _return) override; + void send_get_current_notificationEventId(); + void recv_get_current_notificationEventId(CurrentNotificationEventId& _return); + void get_notification_events_count(NotificationEventsCountResponse& _return, const NotificationEventsCountRequest& rqst) override; + void send_get_notification_events_count(const NotificationEventsCountRequest& rqst); + void recv_get_notification_events_count(NotificationEventsCountResponse& _return); + void fire_listener_event(FireEventResponse& _return, const FireEventRequest& rqst) override; + void send_fire_listener_event(const FireEventRequest& rqst); + void recv_fire_listener_event(FireEventResponse& _return); + void flushCache() override; + void send_flushCache(); + void recv_flushCache(); + void add_write_notification_log(WriteNotificationLogResponse& _return, const WriteNotificationLogRequest& rqst) override; + void send_add_write_notification_log(const WriteNotificationLogRequest& rqst); + void recv_add_write_notification_log(WriteNotificationLogResponse& _return); + void add_write_notification_log_in_batch(WriteNotificationLogBatchResponse& _return, const WriteNotificationLogBatchRequest& rqst) override; + void send_add_write_notification_log_in_batch(const WriteNotificationLogBatchRequest& rqst); + void recv_add_write_notification_log_in_batch(WriteNotificationLogBatchResponse& _return); + void cm_recycle(CmRecycleResponse& _return, const CmRecycleRequest& request) override; + void send_cm_recycle(const CmRecycleRequest& request); + void recv_cm_recycle(CmRecycleResponse& _return); + void get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req) override; + void send_get_file_metadata_by_expr(const GetFileMetadataByExprRequest& req); + void recv_get_file_metadata_by_expr(GetFileMetadataByExprResult& _return); + void get_file_metadata(GetFileMetadataResult& _return, const GetFileMetadataRequest& req) override; + void send_get_file_metadata(const GetFileMetadataRequest& req); + void recv_get_file_metadata(GetFileMetadataResult& _return); + void put_file_metadata(PutFileMetadataResult& _return, const PutFileMetadataRequest& req) override; + void send_put_file_metadata(const PutFileMetadataRequest& req); + void recv_put_file_metadata(PutFileMetadataResult& _return); + void clear_file_metadata(ClearFileMetadataResult& _return, const ClearFileMetadataRequest& req) override; + void send_clear_file_metadata(const ClearFileMetadataRequest& req); + void recv_clear_file_metadata(ClearFileMetadataResult& _return); + void cache_file_metadata(CacheFileMetadataResult& _return, const CacheFileMetadataRequest& req) override; + void send_cache_file_metadata(const CacheFileMetadataRequest& req); + void recv_cache_file_metadata(CacheFileMetadataResult& _return); + void get_metastore_db_uuid(std::string& _return) override; + void send_get_metastore_db_uuid(); + void recv_get_metastore_db_uuid(std::string& _return); + void create_resource_plan(WMCreateResourcePlanResponse& _return, const WMCreateResourcePlanRequest& request) override; + void send_create_resource_plan(const WMCreateResourcePlanRequest& request); + void recv_create_resource_plan(WMCreateResourcePlanResponse& _return); + void get_resource_plan(WMGetResourcePlanResponse& _return, const WMGetResourcePlanRequest& request) override; + void send_get_resource_plan(const WMGetResourcePlanRequest& request); + void recv_get_resource_plan(WMGetResourcePlanResponse& _return); + void get_active_resource_plan(WMGetActiveResourcePlanResponse& _return, const WMGetActiveResourcePlanRequest& request) override; + void send_get_active_resource_plan(const WMGetActiveResourcePlanRequest& request); + void recv_get_active_resource_plan(WMGetActiveResourcePlanResponse& _return); + void get_all_resource_plans(WMGetAllResourcePlanResponse& _return, const WMGetAllResourcePlanRequest& request) override; + void send_get_all_resource_plans(const WMGetAllResourcePlanRequest& request); + void recv_get_all_resource_plans(WMGetAllResourcePlanResponse& _return); + void alter_resource_plan(WMAlterResourcePlanResponse& _return, const WMAlterResourcePlanRequest& request) override; + void send_alter_resource_plan(const WMAlterResourcePlanRequest& request); + void recv_alter_resource_plan(WMAlterResourcePlanResponse& _return); + void validate_resource_plan(WMValidateResourcePlanResponse& _return, const WMValidateResourcePlanRequest& request) override; + void send_validate_resource_plan(const WMValidateResourcePlanRequest& request); + void recv_validate_resource_plan(WMValidateResourcePlanResponse& _return); + void drop_resource_plan(WMDropResourcePlanResponse& _return, const WMDropResourcePlanRequest& request) override; + void send_drop_resource_plan(const WMDropResourcePlanRequest& request); + void recv_drop_resource_plan(WMDropResourcePlanResponse& _return); + void create_wm_trigger(WMCreateTriggerResponse& _return, const WMCreateTriggerRequest& request) override; + void send_create_wm_trigger(const WMCreateTriggerRequest& request); + void recv_create_wm_trigger(WMCreateTriggerResponse& _return); + void alter_wm_trigger(WMAlterTriggerResponse& _return, const WMAlterTriggerRequest& request) override; + void send_alter_wm_trigger(const WMAlterTriggerRequest& request); + void recv_alter_wm_trigger(WMAlterTriggerResponse& _return); + void drop_wm_trigger(WMDropTriggerResponse& _return, const WMDropTriggerRequest& request) override; + void send_drop_wm_trigger(const WMDropTriggerRequest& request); + void recv_drop_wm_trigger(WMDropTriggerResponse& _return); + void get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const WMGetTriggersForResourePlanRequest& request) override; + void send_get_triggers_for_resourceplan(const WMGetTriggersForResourePlanRequest& request); + void recv_get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return); + void create_wm_pool(WMCreatePoolResponse& _return, const WMCreatePoolRequest& request) override; + void send_create_wm_pool(const WMCreatePoolRequest& request); + void recv_create_wm_pool(WMCreatePoolResponse& _return); + void alter_wm_pool(WMAlterPoolResponse& _return, const WMAlterPoolRequest& request) override; + void send_alter_wm_pool(const WMAlterPoolRequest& request); + void recv_alter_wm_pool(WMAlterPoolResponse& _return); + void drop_wm_pool(WMDropPoolResponse& _return, const WMDropPoolRequest& request) override; + void send_drop_wm_pool(const WMDropPoolRequest& request); + void recv_drop_wm_pool(WMDropPoolResponse& _return); + void create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const WMCreateOrUpdateMappingRequest& request) override; + void send_create_or_update_wm_mapping(const WMCreateOrUpdateMappingRequest& request); + void recv_create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return); + void drop_wm_mapping(WMDropMappingResponse& _return, const WMDropMappingRequest& request) override; + void send_drop_wm_mapping(const WMDropMappingRequest& request); + void recv_drop_wm_mapping(WMDropMappingResponse& _return); + void create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return, const WMCreateOrDropTriggerToPoolMappingRequest& request) override; + void send_create_or_drop_wm_trigger_to_pool_mapping(const WMCreateOrDropTriggerToPoolMappingRequest& request); + void recv_create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return); + void create_ischema(const ISchema& schema) override; + void send_create_ischema(const ISchema& schema); + void recv_create_ischema(); + void alter_ischema(const AlterISchemaRequest& rqst) override; + void send_alter_ischema(const AlterISchemaRequest& rqst); + void recv_alter_ischema(); + void get_ischema(ISchema& _return, const ISchemaName& name) override; + void send_get_ischema(const ISchemaName& name); + void recv_get_ischema(ISchema& _return); + void drop_ischema(const ISchemaName& name) override; + void send_drop_ischema(const ISchemaName& name); + void recv_drop_ischema(); + void add_schema_version(const SchemaVersion& schemaVersion) override; + void send_add_schema_version(const SchemaVersion& schemaVersion); + void recv_add_schema_version(); + void get_schema_version(SchemaVersion& _return, const SchemaVersionDescriptor& schemaVersion) override; + void send_get_schema_version(const SchemaVersionDescriptor& schemaVersion); + void recv_get_schema_version(SchemaVersion& _return); + void get_schema_latest_version(SchemaVersion& _return, const ISchemaName& schemaName) override; + void send_get_schema_latest_version(const ISchemaName& schemaName); + void recv_get_schema_latest_version(SchemaVersion& _return); + void get_schema_all_versions(std::vector & _return, const ISchemaName& schemaName) override; + void send_get_schema_all_versions(const ISchemaName& schemaName); + void recv_get_schema_all_versions(std::vector & _return); + void drop_schema_version(const SchemaVersionDescriptor& schemaVersion) override; + void send_drop_schema_version(const SchemaVersionDescriptor& schemaVersion); + void recv_drop_schema_version(); + void get_schemas_by_cols(FindSchemasByColsResp& _return, const FindSchemasByColsRqst& rqst) override; + void send_get_schemas_by_cols(const FindSchemasByColsRqst& rqst); + void recv_get_schemas_by_cols(FindSchemasByColsResp& _return); + void map_schema_version_to_serde(const MapSchemaVersionToSerdeRequest& rqst) override; + void send_map_schema_version_to_serde(const MapSchemaVersionToSerdeRequest& rqst); + void recv_map_schema_version_to_serde(); + void set_schema_version_state(const SetSchemaVersionStateRequest& rqst) override; + void send_set_schema_version_state(const SetSchemaVersionStateRequest& rqst); + void recv_set_schema_version_state(); + void add_serde(const SerDeInfo& serde) override; + void send_add_serde(const SerDeInfo& serde); + void recv_add_serde(); + void get_serde(SerDeInfo& _return, const GetSerdeRequest& rqst) override; + void send_get_serde(const GetSerdeRequest& rqst); + void recv_get_serde(SerDeInfo& _return); + void get_lock_materialization_rebuild(LockResponse& _return, const std::string& dbName, const std::string& tableName, const int64_t txnId) override; + void send_get_lock_materialization_rebuild(const std::string& dbName, const std::string& tableName, const int64_t txnId); + void recv_get_lock_materialization_rebuild(LockResponse& _return); + bool heartbeat_lock_materialization_rebuild(const std::string& dbName, const std::string& tableName, const int64_t txnId) override; + void send_heartbeat_lock_materialization_rebuild(const std::string& dbName, const std::string& tableName, const int64_t txnId); + bool recv_heartbeat_lock_materialization_rebuild(); + void add_runtime_stats(const RuntimeStat& stat) override; + void send_add_runtime_stats(const RuntimeStat& stat); + void recv_add_runtime_stats(); + void get_runtime_stats(std::vector & _return, const GetRuntimeStatsRequest& rqst) override; + void send_get_runtime_stats(const GetRuntimeStatsRequest& rqst); + void recv_get_runtime_stats(std::vector & _return); + void get_partitions_with_specs(GetPartitionsResponse& _return, const GetPartitionsRequest& request) override; + void send_get_partitions_with_specs(const GetPartitionsRequest& request); + void recv_get_partitions_with_specs(GetPartitionsResponse& _return); + void scheduled_query_poll(ScheduledQueryPollResponse& _return, const ScheduledQueryPollRequest& request) override; + void send_scheduled_query_poll(const ScheduledQueryPollRequest& request); + void recv_scheduled_query_poll(ScheduledQueryPollResponse& _return); + void scheduled_query_maintenance(const ScheduledQueryMaintenanceRequest& request) override; + void send_scheduled_query_maintenance(const ScheduledQueryMaintenanceRequest& request); + void recv_scheduled_query_maintenance(); + void scheduled_query_progress(const ScheduledQueryProgressInfo& info) override; + void send_scheduled_query_progress(const ScheduledQueryProgressInfo& info); + void recv_scheduled_query_progress(); + void get_scheduled_query(ScheduledQuery& _return, const ScheduledQueryKey& scheduleKey) override; + void send_get_scheduled_query(const ScheduledQueryKey& scheduleKey); + void recv_get_scheduled_query(ScheduledQuery& _return); + void add_replication_metrics(const ReplicationMetricList& replicationMetricList) override; + void send_add_replication_metrics(const ReplicationMetricList& replicationMetricList); + void recv_add_replication_metrics(); + void get_replication_metrics(ReplicationMetricList& _return, const GetReplicationMetricsRequest& rqst) override; + void send_get_replication_metrics(const GetReplicationMetricsRequest& rqst); + void recv_get_replication_metrics(ReplicationMetricList& _return); + void get_open_txns_req(GetOpenTxnsResponse& _return, const GetOpenTxnsRequest& getOpenTxnsRequest) override; + void send_get_open_txns_req(const GetOpenTxnsRequest& getOpenTxnsRequest); + void recv_get_open_txns_req(GetOpenTxnsResponse& _return); + void create_stored_procedure(const StoredProcedure& proc) override; + void send_create_stored_procedure(const StoredProcedure& proc); + void recv_create_stored_procedure(); + void get_stored_procedure(StoredProcedure& _return, const StoredProcedureRequest& request) override; + void send_get_stored_procedure(const StoredProcedureRequest& request); + void recv_get_stored_procedure(StoredProcedure& _return); + void drop_stored_procedure(const StoredProcedureRequest& request) override; + void send_drop_stored_procedure(const StoredProcedureRequest& request); + void recv_drop_stored_procedure(); + void get_all_stored_procedures(std::vector & _return, const ListStoredProcedureRequest& request) override; + void send_get_all_stored_procedures(const ListStoredProcedureRequest& request); + void recv_get_all_stored_procedures(std::vector & _return); + void find_package(Package& _return, const GetPackageRequest& request) override; + void send_find_package(const GetPackageRequest& request); + void recv_find_package(Package& _return); + void add_package(const AddPackageRequest& request) override; + void send_add_package(const AddPackageRequest& request); + void recv_add_package(); + void get_all_packages(std::vector & _return, const ListPackageRequest& request) override; + void send_get_all_packages(const ListPackageRequest& request); + void recv_get_all_packages(std::vector & _return); + void drop_package(const DropPackageRequest& request) override; + void send_drop_package(const DropPackageRequest& request); + void recv_drop_package(); + void get_all_write_event_info(std::vector & _return, const GetAllWriteEventInfoRequest& request) override; + void send_get_all_write_event_info(const GetAllWriteEventInfoRequest& request); + void recv_get_all_write_event_info(std::vector & _return); +}; + +class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceProcessor { + protected: + ::std::shared_ptr iface_; + virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext) override; + private: + typedef void (ThriftHiveMetastoreProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*); + typedef std::map ProcessMap; + ProcessMap processMap_; + void process_abort_Compactions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_getMetaConf(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_setMetaConf(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_catalog(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_alter_catalog(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_catalog(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_catalogs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_catalog(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_database(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_database_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_database(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_database_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_database(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_database_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_databases(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_all_databases(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_alter_database(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_alter_database_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_dataconnector_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_dataconnector_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_dataconnector_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_dataconnectors(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_alter_dataconnector_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_type(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_type(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_type(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_type_all(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_fields(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_fields_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_fields_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_schema(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_schema_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_schema_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_table(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_table_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_table_with_constraints(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_table_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_constraint(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_primary_key(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_foreign_key(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_unique_constraint(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_not_null_constraint(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_default_constraint(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_check_constraint(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_translate_table_dryrun(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_table(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_table_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_table_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_truncate_table(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_truncate_table_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_tables(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_tables_by_type(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_all_materialized_view_objects_for_rewriting(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_materialized_views_for_rewriting(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_table_meta(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_all_tables(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_tables_ext(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_table_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_table_objects_by_name_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_materialization_invalidation_info(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_update_creation_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_table_names_by_filter(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_alter_table(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_alter_table_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_alter_table_with_cascade(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_alter_table_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_partition_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_partitions_pspec(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_append_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_partitions_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_append_partition_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_append_partition_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_append_partition_by_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_append_partition_by_name_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_partition_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_partition_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_partition_by_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_partition_by_name_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_partitions_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partition_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_exchange_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_exchange_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partition_with_auth(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partition_by_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partitions_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partitions_with_auth(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partitions_pspec(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partition_names(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_fetch_partition_names_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partition_values(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partitions_ps(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partitions_ps_with_auth(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partitions_ps_with_auth_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partition_names_ps(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partition_names_ps_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partition_names_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partitions_by_filter(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partitions_by_filter_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_part_specs_by_filter(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partitions_by_expr(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partitions_spec_by_expr(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_num_partitions_by_filter(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partitions_by_names(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partitions_by_names_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_properties(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_set_properties(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_alter_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_alter_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_alter_partitions_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_alter_partitions_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_alter_partition_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_rename_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_rename_partition_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_partition_name_has_valid_characters(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_config_value(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_partition_name_to_vals(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_partition_name_to_spec(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_markPartitionForEvent(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_isPartitionMarkedForEvent(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_primary_keys(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_foreign_keys(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_unique_constraints(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_not_null_constraints(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_default_constraints(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_check_constraints(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_all_table_constraints(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_update_table_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_update_partition_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_update_table_column_statistics_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_update_partition_column_statistics_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_update_transaction_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_table_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partition_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_table_statistics_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partitions_statistics_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_aggr_stats_for(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_set_aggr_stats_for(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_delete_partition_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_delete_table_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_function(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_function(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_alter_function(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_functions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_function(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_all_functions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_role_names(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_grant_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_revoke_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_list_roles(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_grant_revoke_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_principals_in_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_role_grants_for_principal(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_privilege_set(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_list_privileges(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_grant_privileges(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_revoke_privileges(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_grant_revoke_privileges(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_refresh_privileges(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_set_ugi(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_delegation_token(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_renew_delegation_token(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_cancel_delegation_token(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_token(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_remove_token(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_token(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_all_token_identifiers(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_master_key(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_update_master_key(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_remove_master_key(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_master_keys(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_open_txns(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_open_txns_info(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_open_txns(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_abort_txn(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_abort_txns(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_commit_txn(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_latest_txnid_in_conflict(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_repl_tbl_writeid_state(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_valid_write_ids(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_write_ids_to_min_history(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_allocate_table_write_ids(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_max_allocated_table_write_id(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_seed_write_id(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_seed_txn_id(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_lock(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_check_lock(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_unlock(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_show_locks(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_heartbeat(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_heartbeat_txn_range(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_compact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_compact2(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_show_compact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_submit_for_cleanup(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_dynamic_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_find_next_compact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_find_next_compact2(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_update_compactor_state(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_find_columns_with_stats(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_mark_cleaned(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_mark_compacted(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_mark_failed(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_mark_refused(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_update_compaction_metrics_data(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_remove_compaction_metrics_data(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_set_hadoop_jobid(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_latest_committed_compaction_info(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_next_notification(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_current_notificationEventId(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_notification_events_count(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_fire_listener_event(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_flushCache(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_write_notification_log(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_write_notification_log_in_batch(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_cm_recycle(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_file_metadata_by_expr(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_file_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_put_file_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_clear_file_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_cache_file_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_metastore_db_uuid(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_resource_plan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_resource_plan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_active_resource_plan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_all_resource_plans(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_alter_resource_plan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_validate_resource_plan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_resource_plan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_wm_trigger(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_alter_wm_trigger(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_wm_trigger(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_triggers_for_resourceplan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_wm_pool(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_alter_wm_pool(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_wm_pool(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_or_update_wm_mapping(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_wm_mapping(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_or_drop_wm_trigger_to_pool_mapping(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_ischema(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_alter_ischema(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_ischema(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_ischema(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_schema_version(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_schema_version(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_schema_latest_version(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_schema_all_versions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_schema_version(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_schemas_by_cols(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_map_schema_version_to_serde(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_set_schema_version_state(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_serde(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_serde(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_lock_materialization_rebuild(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_heartbeat_lock_materialization_rebuild(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_runtime_stats(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_runtime_stats(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_partitions_with_specs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_scheduled_query_poll(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_scheduled_query_maintenance(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_scheduled_query_progress(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_scheduled_query(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_replication_metrics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_replication_metrics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_open_txns_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_stored_procedure(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_stored_procedure(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_stored_procedure(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_all_stored_procedures(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_find_package(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_package(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_all_packages(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_package(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_all_write_event_info(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + public: + ThriftHiveMetastoreProcessor(::std::shared_ptr iface) : + ::facebook::fb303::FacebookServiceProcessor(iface), + iface_(iface) { + processMap_["abort_Compactions"] = &ThriftHiveMetastoreProcessor::process_abort_Compactions; + processMap_["getMetaConf"] = &ThriftHiveMetastoreProcessor::process_getMetaConf; + processMap_["setMetaConf"] = &ThriftHiveMetastoreProcessor::process_setMetaConf; + processMap_["create_catalog"] = &ThriftHiveMetastoreProcessor::process_create_catalog; + processMap_["alter_catalog"] = &ThriftHiveMetastoreProcessor::process_alter_catalog; + processMap_["get_catalog"] = &ThriftHiveMetastoreProcessor::process_get_catalog; + processMap_["get_catalogs"] = &ThriftHiveMetastoreProcessor::process_get_catalogs; + processMap_["drop_catalog"] = &ThriftHiveMetastoreProcessor::process_drop_catalog; + processMap_["create_database"] = &ThriftHiveMetastoreProcessor::process_create_database; + processMap_["create_database_req"] = &ThriftHiveMetastoreProcessor::process_create_database_req; + processMap_["get_database"] = &ThriftHiveMetastoreProcessor::process_get_database; + processMap_["get_database_req"] = &ThriftHiveMetastoreProcessor::process_get_database_req; + processMap_["drop_database"] = &ThriftHiveMetastoreProcessor::process_drop_database; + processMap_["drop_database_req"] = &ThriftHiveMetastoreProcessor::process_drop_database_req; + processMap_["get_databases"] = &ThriftHiveMetastoreProcessor::process_get_databases; + processMap_["get_all_databases"] = &ThriftHiveMetastoreProcessor::process_get_all_databases; + processMap_["alter_database"] = &ThriftHiveMetastoreProcessor::process_alter_database; + processMap_["alter_database_req"] = &ThriftHiveMetastoreProcessor::process_alter_database_req; + processMap_["create_dataconnector_req"] = &ThriftHiveMetastoreProcessor::process_create_dataconnector_req; + processMap_["get_dataconnector_req"] = &ThriftHiveMetastoreProcessor::process_get_dataconnector_req; + processMap_["drop_dataconnector_req"] = &ThriftHiveMetastoreProcessor::process_drop_dataconnector_req; + processMap_["get_dataconnectors"] = &ThriftHiveMetastoreProcessor::process_get_dataconnectors; + processMap_["alter_dataconnector_req"] = &ThriftHiveMetastoreProcessor::process_alter_dataconnector_req; + processMap_["get_type"] = &ThriftHiveMetastoreProcessor::process_get_type; + processMap_["create_type"] = &ThriftHiveMetastoreProcessor::process_create_type; + processMap_["drop_type"] = &ThriftHiveMetastoreProcessor::process_drop_type; + processMap_["get_type_all"] = &ThriftHiveMetastoreProcessor::process_get_type_all; + processMap_["get_fields"] = &ThriftHiveMetastoreProcessor::process_get_fields; + processMap_["get_fields_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_get_fields_with_environment_context; + processMap_["get_fields_req"] = &ThriftHiveMetastoreProcessor::process_get_fields_req; + processMap_["get_schema"] = &ThriftHiveMetastoreProcessor::process_get_schema; + processMap_["get_schema_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_get_schema_with_environment_context; + processMap_["get_schema_req"] = &ThriftHiveMetastoreProcessor::process_get_schema_req; + processMap_["create_table"] = &ThriftHiveMetastoreProcessor::process_create_table; + processMap_["create_table_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_create_table_with_environment_context; + processMap_["create_table_with_constraints"] = &ThriftHiveMetastoreProcessor::process_create_table_with_constraints; + processMap_["create_table_req"] = &ThriftHiveMetastoreProcessor::process_create_table_req; + processMap_["drop_constraint"] = &ThriftHiveMetastoreProcessor::process_drop_constraint; + processMap_["add_primary_key"] = &ThriftHiveMetastoreProcessor::process_add_primary_key; + processMap_["add_foreign_key"] = &ThriftHiveMetastoreProcessor::process_add_foreign_key; + processMap_["add_unique_constraint"] = &ThriftHiveMetastoreProcessor::process_add_unique_constraint; + processMap_["add_not_null_constraint"] = &ThriftHiveMetastoreProcessor::process_add_not_null_constraint; + processMap_["add_default_constraint"] = &ThriftHiveMetastoreProcessor::process_add_default_constraint; + processMap_["add_check_constraint"] = &ThriftHiveMetastoreProcessor::process_add_check_constraint; + processMap_["translate_table_dryrun"] = &ThriftHiveMetastoreProcessor::process_translate_table_dryrun; + processMap_["drop_table"] = &ThriftHiveMetastoreProcessor::process_drop_table; + processMap_["drop_table_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_drop_table_with_environment_context; + processMap_["drop_table_req"] = &ThriftHiveMetastoreProcessor::process_drop_table_req; + processMap_["truncate_table"] = &ThriftHiveMetastoreProcessor::process_truncate_table; + processMap_["truncate_table_req"] = &ThriftHiveMetastoreProcessor::process_truncate_table_req; + processMap_["get_tables"] = &ThriftHiveMetastoreProcessor::process_get_tables; + processMap_["get_tables_by_type"] = &ThriftHiveMetastoreProcessor::process_get_tables_by_type; + processMap_["get_all_materialized_view_objects_for_rewriting"] = &ThriftHiveMetastoreProcessor::process_get_all_materialized_view_objects_for_rewriting; + processMap_["get_materialized_views_for_rewriting"] = &ThriftHiveMetastoreProcessor::process_get_materialized_views_for_rewriting; + processMap_["get_table_meta"] = &ThriftHiveMetastoreProcessor::process_get_table_meta; + processMap_["get_all_tables"] = &ThriftHiveMetastoreProcessor::process_get_all_tables; + processMap_["get_tables_ext"] = &ThriftHiveMetastoreProcessor::process_get_tables_ext; + processMap_["get_table_req"] = &ThriftHiveMetastoreProcessor::process_get_table_req; + processMap_["get_table_objects_by_name_req"] = &ThriftHiveMetastoreProcessor::process_get_table_objects_by_name_req; + processMap_["get_materialization_invalidation_info"] = &ThriftHiveMetastoreProcessor::process_get_materialization_invalidation_info; + processMap_["update_creation_metadata"] = &ThriftHiveMetastoreProcessor::process_update_creation_metadata; + processMap_["get_table_names_by_filter"] = &ThriftHiveMetastoreProcessor::process_get_table_names_by_filter; + processMap_["alter_table"] = &ThriftHiveMetastoreProcessor::process_alter_table; + processMap_["alter_table_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_alter_table_with_environment_context; + processMap_["alter_table_with_cascade"] = &ThriftHiveMetastoreProcessor::process_alter_table_with_cascade; + processMap_["alter_table_req"] = &ThriftHiveMetastoreProcessor::process_alter_table_req; + processMap_["add_partition"] = &ThriftHiveMetastoreProcessor::process_add_partition; + processMap_["add_partition_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_add_partition_with_environment_context; + processMap_["add_partitions"] = &ThriftHiveMetastoreProcessor::process_add_partitions; + processMap_["add_partitions_pspec"] = &ThriftHiveMetastoreProcessor::process_add_partitions_pspec; + processMap_["append_partition"] = &ThriftHiveMetastoreProcessor::process_append_partition; + processMap_["add_partitions_req"] = &ThriftHiveMetastoreProcessor::process_add_partitions_req; + processMap_["append_partition_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_append_partition_with_environment_context; + processMap_["append_partition_req"] = &ThriftHiveMetastoreProcessor::process_append_partition_req; + processMap_["append_partition_by_name"] = &ThriftHiveMetastoreProcessor::process_append_partition_by_name; + processMap_["append_partition_by_name_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_append_partition_by_name_with_environment_context; + processMap_["drop_partition"] = &ThriftHiveMetastoreProcessor::process_drop_partition; + processMap_["drop_partition_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_drop_partition_with_environment_context; + processMap_["drop_partition_req"] = &ThriftHiveMetastoreProcessor::process_drop_partition_req; + processMap_["drop_partition_by_name"] = &ThriftHiveMetastoreProcessor::process_drop_partition_by_name; + processMap_["drop_partition_by_name_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_drop_partition_by_name_with_environment_context; + processMap_["drop_partitions_req"] = &ThriftHiveMetastoreProcessor::process_drop_partitions_req; + processMap_["get_partition"] = &ThriftHiveMetastoreProcessor::process_get_partition; + processMap_["get_partition_req"] = &ThriftHiveMetastoreProcessor::process_get_partition_req; + processMap_["exchange_partition"] = &ThriftHiveMetastoreProcessor::process_exchange_partition; + processMap_["exchange_partitions"] = &ThriftHiveMetastoreProcessor::process_exchange_partitions; + processMap_["get_partition_with_auth"] = &ThriftHiveMetastoreProcessor::process_get_partition_with_auth; + processMap_["get_partition_by_name"] = &ThriftHiveMetastoreProcessor::process_get_partition_by_name; + processMap_["get_partitions"] = &ThriftHiveMetastoreProcessor::process_get_partitions; + processMap_["get_partitions_req"] = &ThriftHiveMetastoreProcessor::process_get_partitions_req; + processMap_["get_partitions_with_auth"] = &ThriftHiveMetastoreProcessor::process_get_partitions_with_auth; + processMap_["get_partitions_pspec"] = &ThriftHiveMetastoreProcessor::process_get_partitions_pspec; + processMap_["get_partition_names"] = &ThriftHiveMetastoreProcessor::process_get_partition_names; + processMap_["fetch_partition_names_req"] = &ThriftHiveMetastoreProcessor::process_fetch_partition_names_req; + processMap_["get_partition_values"] = &ThriftHiveMetastoreProcessor::process_get_partition_values; + processMap_["get_partitions_ps"] = &ThriftHiveMetastoreProcessor::process_get_partitions_ps; + processMap_["get_partitions_ps_with_auth"] = &ThriftHiveMetastoreProcessor::process_get_partitions_ps_with_auth; + processMap_["get_partitions_ps_with_auth_req"] = &ThriftHiveMetastoreProcessor::process_get_partitions_ps_with_auth_req; + processMap_["get_partition_names_ps"] = &ThriftHiveMetastoreProcessor::process_get_partition_names_ps; + processMap_["get_partition_names_ps_req"] = &ThriftHiveMetastoreProcessor::process_get_partition_names_ps_req; + processMap_["get_partition_names_req"] = &ThriftHiveMetastoreProcessor::process_get_partition_names_req; + processMap_["get_partitions_by_filter"] = &ThriftHiveMetastoreProcessor::process_get_partitions_by_filter; + processMap_["get_partitions_by_filter_req"] = &ThriftHiveMetastoreProcessor::process_get_partitions_by_filter_req; + processMap_["get_part_specs_by_filter"] = &ThriftHiveMetastoreProcessor::process_get_part_specs_by_filter; + processMap_["get_partitions_by_expr"] = &ThriftHiveMetastoreProcessor::process_get_partitions_by_expr; + processMap_["get_partitions_spec_by_expr"] = &ThriftHiveMetastoreProcessor::process_get_partitions_spec_by_expr; + processMap_["get_num_partitions_by_filter"] = &ThriftHiveMetastoreProcessor::process_get_num_partitions_by_filter; + processMap_["get_partitions_by_names"] = &ThriftHiveMetastoreProcessor::process_get_partitions_by_names; + processMap_["get_partitions_by_names_req"] = &ThriftHiveMetastoreProcessor::process_get_partitions_by_names_req; + processMap_["get_properties"] = &ThriftHiveMetastoreProcessor::process_get_properties; + processMap_["set_properties"] = &ThriftHiveMetastoreProcessor::process_set_properties; + processMap_["alter_partition"] = &ThriftHiveMetastoreProcessor::process_alter_partition; + processMap_["alter_partitions"] = &ThriftHiveMetastoreProcessor::process_alter_partitions; + processMap_["alter_partitions_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_alter_partitions_with_environment_context; + processMap_["alter_partitions_req"] = &ThriftHiveMetastoreProcessor::process_alter_partitions_req; + processMap_["alter_partition_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_alter_partition_with_environment_context; + processMap_["rename_partition"] = &ThriftHiveMetastoreProcessor::process_rename_partition; + processMap_["rename_partition_req"] = &ThriftHiveMetastoreProcessor::process_rename_partition_req; + processMap_["partition_name_has_valid_characters"] = &ThriftHiveMetastoreProcessor::process_partition_name_has_valid_characters; + processMap_["get_config_value"] = &ThriftHiveMetastoreProcessor::process_get_config_value; + processMap_["partition_name_to_vals"] = &ThriftHiveMetastoreProcessor::process_partition_name_to_vals; + processMap_["partition_name_to_spec"] = &ThriftHiveMetastoreProcessor::process_partition_name_to_spec; + processMap_["markPartitionForEvent"] = &ThriftHiveMetastoreProcessor::process_markPartitionForEvent; + processMap_["isPartitionMarkedForEvent"] = &ThriftHiveMetastoreProcessor::process_isPartitionMarkedForEvent; + processMap_["get_primary_keys"] = &ThriftHiveMetastoreProcessor::process_get_primary_keys; + processMap_["get_foreign_keys"] = &ThriftHiveMetastoreProcessor::process_get_foreign_keys; + processMap_["get_unique_constraints"] = &ThriftHiveMetastoreProcessor::process_get_unique_constraints; + processMap_["get_not_null_constraints"] = &ThriftHiveMetastoreProcessor::process_get_not_null_constraints; + processMap_["get_default_constraints"] = &ThriftHiveMetastoreProcessor::process_get_default_constraints; + processMap_["get_check_constraints"] = &ThriftHiveMetastoreProcessor::process_get_check_constraints; + processMap_["get_all_table_constraints"] = &ThriftHiveMetastoreProcessor::process_get_all_table_constraints; + processMap_["update_table_column_statistics"] = &ThriftHiveMetastoreProcessor::process_update_table_column_statistics; + processMap_["update_partition_column_statistics"] = &ThriftHiveMetastoreProcessor::process_update_partition_column_statistics; + processMap_["update_table_column_statistics_req"] = &ThriftHiveMetastoreProcessor::process_update_table_column_statistics_req; + processMap_["update_partition_column_statistics_req"] = &ThriftHiveMetastoreProcessor::process_update_partition_column_statistics_req; + processMap_["update_transaction_statistics"] = &ThriftHiveMetastoreProcessor::process_update_transaction_statistics; + processMap_["get_table_column_statistics"] = &ThriftHiveMetastoreProcessor::process_get_table_column_statistics; + processMap_["get_partition_column_statistics"] = &ThriftHiveMetastoreProcessor::process_get_partition_column_statistics; + processMap_["get_table_statistics_req"] = &ThriftHiveMetastoreProcessor::process_get_table_statistics_req; + processMap_["get_partitions_statistics_req"] = &ThriftHiveMetastoreProcessor::process_get_partitions_statistics_req; + processMap_["get_aggr_stats_for"] = &ThriftHiveMetastoreProcessor::process_get_aggr_stats_for; + processMap_["set_aggr_stats_for"] = &ThriftHiveMetastoreProcessor::process_set_aggr_stats_for; + processMap_["delete_partition_column_statistics"] = &ThriftHiveMetastoreProcessor::process_delete_partition_column_statistics; + processMap_["delete_table_column_statistics"] = &ThriftHiveMetastoreProcessor::process_delete_table_column_statistics; + processMap_["create_function"] = &ThriftHiveMetastoreProcessor::process_create_function; + processMap_["drop_function"] = &ThriftHiveMetastoreProcessor::process_drop_function; + processMap_["alter_function"] = &ThriftHiveMetastoreProcessor::process_alter_function; + processMap_["get_functions"] = &ThriftHiveMetastoreProcessor::process_get_functions; + processMap_["get_function"] = &ThriftHiveMetastoreProcessor::process_get_function; + processMap_["get_all_functions"] = &ThriftHiveMetastoreProcessor::process_get_all_functions; + processMap_["create_role"] = &ThriftHiveMetastoreProcessor::process_create_role; + processMap_["drop_role"] = &ThriftHiveMetastoreProcessor::process_drop_role; + processMap_["get_role_names"] = &ThriftHiveMetastoreProcessor::process_get_role_names; + processMap_["grant_role"] = &ThriftHiveMetastoreProcessor::process_grant_role; + processMap_["revoke_role"] = &ThriftHiveMetastoreProcessor::process_revoke_role; + processMap_["list_roles"] = &ThriftHiveMetastoreProcessor::process_list_roles; + processMap_["grant_revoke_role"] = &ThriftHiveMetastoreProcessor::process_grant_revoke_role; + processMap_["get_principals_in_role"] = &ThriftHiveMetastoreProcessor::process_get_principals_in_role; + processMap_["get_role_grants_for_principal"] = &ThriftHiveMetastoreProcessor::process_get_role_grants_for_principal; + processMap_["get_privilege_set"] = &ThriftHiveMetastoreProcessor::process_get_privilege_set; + processMap_["list_privileges"] = &ThriftHiveMetastoreProcessor::process_list_privileges; + processMap_["grant_privileges"] = &ThriftHiveMetastoreProcessor::process_grant_privileges; + processMap_["revoke_privileges"] = &ThriftHiveMetastoreProcessor::process_revoke_privileges; + processMap_["grant_revoke_privileges"] = &ThriftHiveMetastoreProcessor::process_grant_revoke_privileges; + processMap_["refresh_privileges"] = &ThriftHiveMetastoreProcessor::process_refresh_privileges; + processMap_["set_ugi"] = &ThriftHiveMetastoreProcessor::process_set_ugi; + processMap_["get_delegation_token"] = &ThriftHiveMetastoreProcessor::process_get_delegation_token; + processMap_["renew_delegation_token"] = &ThriftHiveMetastoreProcessor::process_renew_delegation_token; + processMap_["cancel_delegation_token"] = &ThriftHiveMetastoreProcessor::process_cancel_delegation_token; + processMap_["add_token"] = &ThriftHiveMetastoreProcessor::process_add_token; + processMap_["remove_token"] = &ThriftHiveMetastoreProcessor::process_remove_token; + processMap_["get_token"] = &ThriftHiveMetastoreProcessor::process_get_token; + processMap_["get_all_token_identifiers"] = &ThriftHiveMetastoreProcessor::process_get_all_token_identifiers; + processMap_["add_master_key"] = &ThriftHiveMetastoreProcessor::process_add_master_key; + processMap_["update_master_key"] = &ThriftHiveMetastoreProcessor::process_update_master_key; + processMap_["remove_master_key"] = &ThriftHiveMetastoreProcessor::process_remove_master_key; + processMap_["get_master_keys"] = &ThriftHiveMetastoreProcessor::process_get_master_keys; + processMap_["get_open_txns"] = &ThriftHiveMetastoreProcessor::process_get_open_txns; + processMap_["get_open_txns_info"] = &ThriftHiveMetastoreProcessor::process_get_open_txns_info; + processMap_["open_txns"] = &ThriftHiveMetastoreProcessor::process_open_txns; + processMap_["abort_txn"] = &ThriftHiveMetastoreProcessor::process_abort_txn; + processMap_["abort_txns"] = &ThriftHiveMetastoreProcessor::process_abort_txns; + processMap_["commit_txn"] = &ThriftHiveMetastoreProcessor::process_commit_txn; + processMap_["get_latest_txnid_in_conflict"] = &ThriftHiveMetastoreProcessor::process_get_latest_txnid_in_conflict; + processMap_["repl_tbl_writeid_state"] = &ThriftHiveMetastoreProcessor::process_repl_tbl_writeid_state; + processMap_["get_valid_write_ids"] = &ThriftHiveMetastoreProcessor::process_get_valid_write_ids; + processMap_["add_write_ids_to_min_history"] = &ThriftHiveMetastoreProcessor::process_add_write_ids_to_min_history; + processMap_["allocate_table_write_ids"] = &ThriftHiveMetastoreProcessor::process_allocate_table_write_ids; + processMap_["get_max_allocated_table_write_id"] = &ThriftHiveMetastoreProcessor::process_get_max_allocated_table_write_id; + processMap_["seed_write_id"] = &ThriftHiveMetastoreProcessor::process_seed_write_id; + processMap_["seed_txn_id"] = &ThriftHiveMetastoreProcessor::process_seed_txn_id; + processMap_["lock"] = &ThriftHiveMetastoreProcessor::process_lock; + processMap_["check_lock"] = &ThriftHiveMetastoreProcessor::process_check_lock; + processMap_["unlock"] = &ThriftHiveMetastoreProcessor::process_unlock; + processMap_["show_locks"] = &ThriftHiveMetastoreProcessor::process_show_locks; + processMap_["heartbeat"] = &ThriftHiveMetastoreProcessor::process_heartbeat; + processMap_["heartbeat_txn_range"] = &ThriftHiveMetastoreProcessor::process_heartbeat_txn_range; + processMap_["compact"] = &ThriftHiveMetastoreProcessor::process_compact; + processMap_["compact2"] = &ThriftHiveMetastoreProcessor::process_compact2; + processMap_["show_compact"] = &ThriftHiveMetastoreProcessor::process_show_compact; + processMap_["submit_for_cleanup"] = &ThriftHiveMetastoreProcessor::process_submit_for_cleanup; + processMap_["add_dynamic_partitions"] = &ThriftHiveMetastoreProcessor::process_add_dynamic_partitions; + processMap_["find_next_compact"] = &ThriftHiveMetastoreProcessor::process_find_next_compact; + processMap_["find_next_compact2"] = &ThriftHiveMetastoreProcessor::process_find_next_compact2; + processMap_["update_compactor_state"] = &ThriftHiveMetastoreProcessor::process_update_compactor_state; + processMap_["find_columns_with_stats"] = &ThriftHiveMetastoreProcessor::process_find_columns_with_stats; + processMap_["mark_cleaned"] = &ThriftHiveMetastoreProcessor::process_mark_cleaned; + processMap_["mark_compacted"] = &ThriftHiveMetastoreProcessor::process_mark_compacted; + processMap_["mark_failed"] = &ThriftHiveMetastoreProcessor::process_mark_failed; + processMap_["mark_refused"] = &ThriftHiveMetastoreProcessor::process_mark_refused; + processMap_["update_compaction_metrics_data"] = &ThriftHiveMetastoreProcessor::process_update_compaction_metrics_data; + processMap_["remove_compaction_metrics_data"] = &ThriftHiveMetastoreProcessor::process_remove_compaction_metrics_data; + processMap_["set_hadoop_jobid"] = &ThriftHiveMetastoreProcessor::process_set_hadoop_jobid; + processMap_["get_latest_committed_compaction_info"] = &ThriftHiveMetastoreProcessor::process_get_latest_committed_compaction_info; + processMap_["get_next_notification"] = &ThriftHiveMetastoreProcessor::process_get_next_notification; + processMap_["get_current_notificationEventId"] = &ThriftHiveMetastoreProcessor::process_get_current_notificationEventId; + processMap_["get_notification_events_count"] = &ThriftHiveMetastoreProcessor::process_get_notification_events_count; + processMap_["fire_listener_event"] = &ThriftHiveMetastoreProcessor::process_fire_listener_event; + processMap_["flushCache"] = &ThriftHiveMetastoreProcessor::process_flushCache; + processMap_["add_write_notification_log"] = &ThriftHiveMetastoreProcessor::process_add_write_notification_log; + processMap_["add_write_notification_log_in_batch"] = &ThriftHiveMetastoreProcessor::process_add_write_notification_log_in_batch; + processMap_["cm_recycle"] = &ThriftHiveMetastoreProcessor::process_cm_recycle; + processMap_["get_file_metadata_by_expr"] = &ThriftHiveMetastoreProcessor::process_get_file_metadata_by_expr; + processMap_["get_file_metadata"] = &ThriftHiveMetastoreProcessor::process_get_file_metadata; + processMap_["put_file_metadata"] = &ThriftHiveMetastoreProcessor::process_put_file_metadata; + processMap_["clear_file_metadata"] = &ThriftHiveMetastoreProcessor::process_clear_file_metadata; + processMap_["cache_file_metadata"] = &ThriftHiveMetastoreProcessor::process_cache_file_metadata; + processMap_["get_metastore_db_uuid"] = &ThriftHiveMetastoreProcessor::process_get_metastore_db_uuid; + processMap_["create_resource_plan"] = &ThriftHiveMetastoreProcessor::process_create_resource_plan; + processMap_["get_resource_plan"] = &ThriftHiveMetastoreProcessor::process_get_resource_plan; + processMap_["get_active_resource_plan"] = &ThriftHiveMetastoreProcessor::process_get_active_resource_plan; + processMap_["get_all_resource_plans"] = &ThriftHiveMetastoreProcessor::process_get_all_resource_plans; + processMap_["alter_resource_plan"] = &ThriftHiveMetastoreProcessor::process_alter_resource_plan; + processMap_["validate_resource_plan"] = &ThriftHiveMetastoreProcessor::process_validate_resource_plan; + processMap_["drop_resource_plan"] = &ThriftHiveMetastoreProcessor::process_drop_resource_plan; + processMap_["create_wm_trigger"] = &ThriftHiveMetastoreProcessor::process_create_wm_trigger; + processMap_["alter_wm_trigger"] = &ThriftHiveMetastoreProcessor::process_alter_wm_trigger; + processMap_["drop_wm_trigger"] = &ThriftHiveMetastoreProcessor::process_drop_wm_trigger; + processMap_["get_triggers_for_resourceplan"] = &ThriftHiveMetastoreProcessor::process_get_triggers_for_resourceplan; + processMap_["create_wm_pool"] = &ThriftHiveMetastoreProcessor::process_create_wm_pool; + processMap_["alter_wm_pool"] = &ThriftHiveMetastoreProcessor::process_alter_wm_pool; + processMap_["drop_wm_pool"] = &ThriftHiveMetastoreProcessor::process_drop_wm_pool; + processMap_["create_or_update_wm_mapping"] = &ThriftHiveMetastoreProcessor::process_create_or_update_wm_mapping; + processMap_["drop_wm_mapping"] = &ThriftHiveMetastoreProcessor::process_drop_wm_mapping; + processMap_["create_or_drop_wm_trigger_to_pool_mapping"] = &ThriftHiveMetastoreProcessor::process_create_or_drop_wm_trigger_to_pool_mapping; + processMap_["create_ischema"] = &ThriftHiveMetastoreProcessor::process_create_ischema; + processMap_["alter_ischema"] = &ThriftHiveMetastoreProcessor::process_alter_ischema; + processMap_["get_ischema"] = &ThriftHiveMetastoreProcessor::process_get_ischema; + processMap_["drop_ischema"] = &ThriftHiveMetastoreProcessor::process_drop_ischema; + processMap_["add_schema_version"] = &ThriftHiveMetastoreProcessor::process_add_schema_version; + processMap_["get_schema_version"] = &ThriftHiveMetastoreProcessor::process_get_schema_version; + processMap_["get_schema_latest_version"] = &ThriftHiveMetastoreProcessor::process_get_schema_latest_version; + processMap_["get_schema_all_versions"] = &ThriftHiveMetastoreProcessor::process_get_schema_all_versions; + processMap_["drop_schema_version"] = &ThriftHiveMetastoreProcessor::process_drop_schema_version; + processMap_["get_schemas_by_cols"] = &ThriftHiveMetastoreProcessor::process_get_schemas_by_cols; + processMap_["map_schema_version_to_serde"] = &ThriftHiveMetastoreProcessor::process_map_schema_version_to_serde; + processMap_["set_schema_version_state"] = &ThriftHiveMetastoreProcessor::process_set_schema_version_state; + processMap_["add_serde"] = &ThriftHiveMetastoreProcessor::process_add_serde; + processMap_["get_serde"] = &ThriftHiveMetastoreProcessor::process_get_serde; + processMap_["get_lock_materialization_rebuild"] = &ThriftHiveMetastoreProcessor::process_get_lock_materialization_rebuild; + processMap_["heartbeat_lock_materialization_rebuild"] = &ThriftHiveMetastoreProcessor::process_heartbeat_lock_materialization_rebuild; + processMap_["add_runtime_stats"] = &ThriftHiveMetastoreProcessor::process_add_runtime_stats; + processMap_["get_runtime_stats"] = &ThriftHiveMetastoreProcessor::process_get_runtime_stats; + processMap_["get_partitions_with_specs"] = &ThriftHiveMetastoreProcessor::process_get_partitions_with_specs; + processMap_["scheduled_query_poll"] = &ThriftHiveMetastoreProcessor::process_scheduled_query_poll; + processMap_["scheduled_query_maintenance"] = &ThriftHiveMetastoreProcessor::process_scheduled_query_maintenance; + processMap_["scheduled_query_progress"] = &ThriftHiveMetastoreProcessor::process_scheduled_query_progress; + processMap_["get_scheduled_query"] = &ThriftHiveMetastoreProcessor::process_get_scheduled_query; + processMap_["add_replication_metrics"] = &ThriftHiveMetastoreProcessor::process_add_replication_metrics; + processMap_["get_replication_metrics"] = &ThriftHiveMetastoreProcessor::process_get_replication_metrics; + processMap_["get_open_txns_req"] = &ThriftHiveMetastoreProcessor::process_get_open_txns_req; + processMap_["create_stored_procedure"] = &ThriftHiveMetastoreProcessor::process_create_stored_procedure; + processMap_["get_stored_procedure"] = &ThriftHiveMetastoreProcessor::process_get_stored_procedure; + processMap_["drop_stored_procedure"] = &ThriftHiveMetastoreProcessor::process_drop_stored_procedure; + processMap_["get_all_stored_procedures"] = &ThriftHiveMetastoreProcessor::process_get_all_stored_procedures; + processMap_["find_package"] = &ThriftHiveMetastoreProcessor::process_find_package; + processMap_["add_package"] = &ThriftHiveMetastoreProcessor::process_add_package; + processMap_["get_all_packages"] = &ThriftHiveMetastoreProcessor::process_get_all_packages; + processMap_["drop_package"] = &ThriftHiveMetastoreProcessor::process_drop_package; + processMap_["get_all_write_event_info"] = &ThriftHiveMetastoreProcessor::process_get_all_write_event_info; + } + + virtual ~ThriftHiveMetastoreProcessor() {} +}; + +class ThriftHiveMetastoreProcessorFactory : public ::apache::thrift::TProcessorFactory { + public: + ThriftHiveMetastoreProcessorFactory(const ::std::shared_ptr< ThriftHiveMetastoreIfFactory >& handlerFactory) noexcept : + handlerFactory_(handlerFactory) {} + + ::std::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) override; + + protected: + ::std::shared_ptr< ThriftHiveMetastoreIfFactory > handlerFactory_; +}; + +class ThriftHiveMetastoreMultiface : virtual public ThriftHiveMetastoreIf, public ::facebook::fb303::FacebookServiceMultiface { + public: + ThriftHiveMetastoreMultiface(std::vector >& ifaces) : ifaces_(ifaces) { + std::vector >::iterator iter; + for (iter = ifaces.begin(); iter != ifaces.end(); ++iter) { + ::facebook::fb303::FacebookServiceMultiface::add(*iter); + } + } + virtual ~ThriftHiveMetastoreMultiface() {} + protected: + std::vector > ifaces_; + ThriftHiveMetastoreMultiface() {} + void add(::std::shared_ptr iface) { + ::facebook::fb303::FacebookServiceMultiface::add(iface); + ifaces_.push_back(iface); + } + public: + void abort_Compactions(AbortCompactResponse& _return, const AbortCompactionRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->abort_Compactions(_return, rqst); + } + ifaces_[i]->abort_Compactions(_return, rqst); + return; + } + + void getMetaConf(std::string& _return, const std::string& key) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->getMetaConf(_return, key); + } + ifaces_[i]->getMetaConf(_return, key); + return; + } + + void setMetaConf(const std::string& key, const std::string& value) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->setMetaConf(key, value); + } + ifaces_[i]->setMetaConf(key, value); + } + + void create_catalog(const CreateCatalogRequest& catalog) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->create_catalog(catalog); + } + ifaces_[i]->create_catalog(catalog); + } + + void alter_catalog(const AlterCatalogRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->alter_catalog(rqst); + } + ifaces_[i]->alter_catalog(rqst); + } + + void get_catalog(GetCatalogResponse& _return, const GetCatalogRequest& catName) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_catalog(_return, catName); + } + ifaces_[i]->get_catalog(_return, catName); + return; + } + + void get_catalogs(GetCatalogsResponse& _return) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_catalogs(_return); + } + ifaces_[i]->get_catalogs(_return); + return; + } + + void drop_catalog(const DropCatalogRequest& catName) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_catalog(catName); + } + ifaces_[i]->drop_catalog(catName); + } + + void create_database(const Database& database) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->create_database(database); + } + ifaces_[i]->create_database(database); + } + + void create_database_req(const CreateDatabaseRequest& createDatabaseRequest) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->create_database_req(createDatabaseRequest); + } + ifaces_[i]->create_database_req(createDatabaseRequest); + } + + void get_database(Database& _return, const std::string& name) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_database(_return, name); + } + ifaces_[i]->get_database(_return, name); + return; + } + + void get_database_req(Database& _return, const GetDatabaseRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_database_req(_return, request); + } + ifaces_[i]->get_database_req(_return, request); + return; + } + + void drop_database(const std::string& name, const bool deleteData, const bool cascade) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_database(name, deleteData, cascade); + } + ifaces_[i]->drop_database(name, deleteData, cascade); + } + + void drop_database_req(const DropDatabaseRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_database_req(req); + } + ifaces_[i]->drop_database_req(req); + } + + void get_databases(std::vector & _return, const std::string& pattern) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_databases(_return, pattern); + } + ifaces_[i]->get_databases(_return, pattern); + return; + } + + void get_all_databases(std::vector & _return) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_all_databases(_return); + } + ifaces_[i]->get_all_databases(_return); + return; + } + + void alter_database(const std::string& dbname, const Database& db) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->alter_database(dbname, db); + } + ifaces_[i]->alter_database(dbname, db); + } + + void alter_database_req(const AlterDatabaseRequest& alterDbReq) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->alter_database_req(alterDbReq); + } + ifaces_[i]->alter_database_req(alterDbReq); + } + + void create_dataconnector_req(const CreateDataConnectorRequest& connectorReq) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->create_dataconnector_req(connectorReq); + } + ifaces_[i]->create_dataconnector_req(connectorReq); + } + + void get_dataconnector_req(DataConnector& _return, const GetDataConnectorRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_dataconnector_req(_return, request); + } + ifaces_[i]->get_dataconnector_req(_return, request); + return; + } + + void drop_dataconnector_req(const DropDataConnectorRequest& dropDcReq) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_dataconnector_req(dropDcReq); + } + ifaces_[i]->drop_dataconnector_req(dropDcReq); + } + + void get_dataconnectors(std::vector & _return) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_dataconnectors(_return); + } + ifaces_[i]->get_dataconnectors(_return); + return; + } + + void alter_dataconnector_req(const AlterDataConnectorRequest& alterReq) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->alter_dataconnector_req(alterReq); + } + ifaces_[i]->alter_dataconnector_req(alterReq); + } + + void get_type(Type& _return, const std::string& name) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_type(_return, name); + } + ifaces_[i]->get_type(_return, name); + return; + } + + bool create_type(const Type& type) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->create_type(type); + } + return ifaces_[i]->create_type(type); + } + + bool drop_type(const std::string& type) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_type(type); + } + return ifaces_[i]->drop_type(type); + } + + void get_type_all(std::map & _return, const std::string& name) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_type_all(_return, name); + } + ifaces_[i]->get_type_all(_return, name); + return; + } + + void get_fields(std::vector & _return, const std::string& db_name, const std::string& table_name) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_fields(_return, db_name, table_name); + } + ifaces_[i]->get_fields(_return, db_name, table_name); + return; + } + + void get_fields_with_environment_context(std::vector & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_fields_with_environment_context(_return, db_name, table_name, environment_context); + } + ifaces_[i]->get_fields_with_environment_context(_return, db_name, table_name, environment_context); + return; + } + + void get_fields_req(GetFieldsResponse& _return, const GetFieldsRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_fields_req(_return, req); + } + ifaces_[i]->get_fields_req(_return, req); + return; + } + + void get_schema(std::vector & _return, const std::string& db_name, const std::string& table_name) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_schema(_return, db_name, table_name); + } + ifaces_[i]->get_schema(_return, db_name, table_name); + return; + } + + void get_schema_with_environment_context(std::vector & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_schema_with_environment_context(_return, db_name, table_name, environment_context); + } + ifaces_[i]->get_schema_with_environment_context(_return, db_name, table_name, environment_context); + return; + } + + void get_schema_req(GetSchemaResponse& _return, const GetSchemaRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_schema_req(_return, req); + } + ifaces_[i]->get_schema_req(_return, req); + return; + } + + void create_table(const Table& tbl) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->create_table(tbl); + } + ifaces_[i]->create_table(tbl); + } + + void create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->create_table_with_environment_context(tbl, environment_context); + } + ifaces_[i]->create_table_with_environment_context(tbl, environment_context); + } + + void create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys, const std::vector & uniqueConstraints, const std::vector & notNullConstraints, const std::vector & defaultConstraints, const std::vector & checkConstraints) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->create_table_with_constraints(tbl, primaryKeys, foreignKeys, uniqueConstraints, notNullConstraints, defaultConstraints, checkConstraints); + } + ifaces_[i]->create_table_with_constraints(tbl, primaryKeys, foreignKeys, uniqueConstraints, notNullConstraints, defaultConstraints, checkConstraints); + } + + void create_table_req(const CreateTableRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->create_table_req(request); + } + ifaces_[i]->create_table_req(request); + } + + void drop_constraint(const DropConstraintRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_constraint(req); + } + ifaces_[i]->drop_constraint(req); + } + + void add_primary_key(const AddPrimaryKeyRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_primary_key(req); + } + ifaces_[i]->add_primary_key(req); + } + + void add_foreign_key(const AddForeignKeyRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_foreign_key(req); + } + ifaces_[i]->add_foreign_key(req); + } + + void add_unique_constraint(const AddUniqueConstraintRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_unique_constraint(req); + } + ifaces_[i]->add_unique_constraint(req); + } + + void add_not_null_constraint(const AddNotNullConstraintRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_not_null_constraint(req); + } + ifaces_[i]->add_not_null_constraint(req); + } + + void add_default_constraint(const AddDefaultConstraintRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_default_constraint(req); + } + ifaces_[i]->add_default_constraint(req); + } + + void add_check_constraint(const AddCheckConstraintRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_check_constraint(req); + } + ifaces_[i]->add_check_constraint(req); + } + + void translate_table_dryrun(Table& _return, const CreateTableRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->translate_table_dryrun(_return, request); + } + ifaces_[i]->translate_table_dryrun(_return, request); + return; + } + + void drop_table(const std::string& dbname, const std::string& name, const bool deleteData) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_table(dbname, name, deleteData); + } + ifaces_[i]->drop_table(dbname, name, deleteData); + } + + void drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_table_with_environment_context(dbname, name, deleteData, environment_context); + } + ifaces_[i]->drop_table_with_environment_context(dbname, name, deleteData, environment_context); + } + + void drop_table_req(const DropTableRequest& dropTableReq) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_table_req(dropTableReq); + } + ifaces_[i]->drop_table_req(dropTableReq); + } + + void truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->truncate_table(dbName, tableName, partNames); + } + ifaces_[i]->truncate_table(dbName, tableName, partNames); + } + + void truncate_table_req(TruncateTableResponse& _return, const TruncateTableRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->truncate_table_req(_return, req); + } + ifaces_[i]->truncate_table_req(_return, req); + return; + } + + void get_tables(std::vector & _return, const std::string& db_name, const std::string& pattern) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_tables(_return, db_name, pattern); + } + ifaces_[i]->get_tables(_return, db_name, pattern); + return; + } + + void get_tables_by_type(std::vector & _return, const std::string& db_name, const std::string& pattern, const std::string& tableType) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_tables_by_type(_return, db_name, pattern, tableType); + } + ifaces_[i]->get_tables_by_type(_return, db_name, pattern, tableType); + return; + } + + void get_all_materialized_view_objects_for_rewriting(std::vector
& _return) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_all_materialized_view_objects_for_rewriting(_return); + } + ifaces_[i]->get_all_materialized_view_objects_for_rewriting(_return); + return; + } + + void get_materialized_views_for_rewriting(std::vector & _return, const std::string& db_name) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_materialized_views_for_rewriting(_return, db_name); + } + ifaces_[i]->get_materialized_views_for_rewriting(_return, db_name); + return; + } + + void get_table_meta(std::vector & _return, const std::string& db_patterns, const std::string& tbl_patterns, const std::vector & tbl_types) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_table_meta(_return, db_patterns, tbl_patterns, tbl_types); + } + ifaces_[i]->get_table_meta(_return, db_patterns, tbl_patterns, tbl_types); + return; + } + + void get_all_tables(std::vector & _return, const std::string& db_name) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_all_tables(_return, db_name); + } + ifaces_[i]->get_all_tables(_return, db_name); + return; + } + + void get_tables_ext(std::vector & _return, const GetTablesExtRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_tables_ext(_return, req); + } + ifaces_[i]->get_tables_ext(_return, req); + return; + } + + void get_table_req(GetTableResult& _return, const GetTableRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_table_req(_return, req); + } + ifaces_[i]->get_table_req(_return, req); + return; + } + + void get_table_objects_by_name_req(GetTablesResult& _return, const GetTablesRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_table_objects_by_name_req(_return, req); + } + ifaces_[i]->get_table_objects_by_name_req(_return, req); + return; + } + + void get_materialization_invalidation_info(Materialization& _return, const CreationMetadata& creation_metadata, const std::string& validTxnList) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_materialization_invalidation_info(_return, creation_metadata, validTxnList); + } + ifaces_[i]->get_materialization_invalidation_info(_return, creation_metadata, validTxnList); + return; + } + + void update_creation_metadata(const std::string& catName, const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->update_creation_metadata(catName, dbname, tbl_name, creation_metadata); + } + ifaces_[i]->update_creation_metadata(catName, dbname, tbl_name, creation_metadata); + } + + void get_table_names_by_filter(std::vector & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_table_names_by_filter(_return, dbname, filter, max_tables); + } + ifaces_[i]->get_table_names_by_filter(_return, dbname, filter, max_tables); + return; + } + + void alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->alter_table(dbname, tbl_name, new_tbl); + } + ifaces_[i]->alter_table(dbname, tbl_name, new_tbl); + } + + void alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->alter_table_with_environment_context(dbname, tbl_name, new_tbl, environment_context); + } + ifaces_[i]->alter_table_with_environment_context(dbname, tbl_name, new_tbl, environment_context); + } + + void alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->alter_table_with_cascade(dbname, tbl_name, new_tbl, cascade); + } + ifaces_[i]->alter_table_with_cascade(dbname, tbl_name, new_tbl, cascade); + } + + void alter_table_req(AlterTableResponse& _return, const AlterTableRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->alter_table_req(_return, req); + } + ifaces_[i]->alter_table_req(_return, req); + return; + } + + void add_partition(Partition& _return, const Partition& new_part) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_partition(_return, new_part); + } + ifaces_[i]->add_partition(_return, new_part); + return; + } + + void add_partition_with_environment_context(Partition& _return, const Partition& new_part, const EnvironmentContext& environment_context) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_partition_with_environment_context(_return, new_part, environment_context); + } + ifaces_[i]->add_partition_with_environment_context(_return, new_part, environment_context); + return; + } + + int32_t add_partitions(const std::vector & new_parts) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_partitions(new_parts); + } + return ifaces_[i]->add_partitions(new_parts); + } + + int32_t add_partitions_pspec(const std::vector & new_parts) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_partitions_pspec(new_parts); + } + return ifaces_[i]->add_partitions_pspec(new_parts); + } + + void append_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->append_partition(_return, db_name, tbl_name, part_vals); + } + ifaces_[i]->append_partition(_return, db_name, tbl_name, part_vals); + return; + } + + void add_partitions_req(AddPartitionsResult& _return, const AddPartitionsRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_partitions_req(_return, request); + } + ifaces_[i]->add_partitions_req(_return, request); + return; + } + + void append_partition_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const EnvironmentContext& environment_context) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->append_partition_with_environment_context(_return, db_name, tbl_name, part_vals, environment_context); + } + ifaces_[i]->append_partition_with_environment_context(_return, db_name, tbl_name, part_vals, environment_context); + return; + } + + void append_partition_req(Partition& _return, const AppendPartitionsRequest& appendPartitionsReq) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->append_partition_req(_return, appendPartitionsReq); + } + ifaces_[i]->append_partition_req(_return, appendPartitionsReq); + return; + } + + void append_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->append_partition_by_name(_return, db_name, tbl_name, part_name); + } + ifaces_[i]->append_partition_by_name(_return, db_name, tbl_name, part_name); + return; + } + + void append_partition_by_name_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->append_partition_by_name_with_environment_context(_return, db_name, tbl_name, part_name, environment_context); + } + ifaces_[i]->append_partition_by_name_with_environment_context(_return, db_name, tbl_name, part_name, environment_context); + return; + } + + bool drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_partition(db_name, tbl_name, part_vals, deleteData); + } + return ifaces_[i]->drop_partition(db_name, tbl_name, part_vals, deleteData); + } + + bool drop_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData, const EnvironmentContext& environment_context) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_partition_with_environment_context(db_name, tbl_name, part_vals, deleteData, environment_context); + } + return ifaces_[i]->drop_partition_with_environment_context(db_name, tbl_name, part_vals, deleteData, environment_context); + } + + bool drop_partition_req(const DropPartitionRequest& dropPartitionReq) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_partition_req(dropPartitionReq); + } + return ifaces_[i]->drop_partition_req(dropPartitionReq); + } + + bool drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_partition_by_name(db_name, tbl_name, part_name, deleteData); + } + return ifaces_[i]->drop_partition_by_name(db_name, tbl_name, part_name, deleteData); + } + + bool drop_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData, const EnvironmentContext& environment_context) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_partition_by_name_with_environment_context(db_name, tbl_name, part_name, deleteData, environment_context); + } + return ifaces_[i]->drop_partition_by_name_with_environment_context(db_name, tbl_name, part_name, deleteData, environment_context); + } + + void drop_partitions_req(DropPartitionsResult& _return, const DropPartitionsRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_partitions_req(_return, req); + } + ifaces_[i]->drop_partitions_req(_return, req); + return; + } + + void get_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partition(_return, db_name, tbl_name, part_vals); + } + ifaces_[i]->get_partition(_return, db_name, tbl_name, part_vals); + return; + } + + void get_partition_req(GetPartitionResponse& _return, const GetPartitionRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partition_req(_return, req); + } + ifaces_[i]->get_partition_req(_return, req); + return; + } + + void exchange_partition(Partition& _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->exchange_partition(_return, partitionSpecs, source_db, source_table_name, dest_db, dest_table_name); + } + ifaces_[i]->exchange_partition(_return, partitionSpecs, source_db, source_table_name, dest_db, dest_table_name); + return; + } + + void exchange_partitions(std::vector & _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->exchange_partitions(_return, partitionSpecs, source_db, source_table_name, dest_db, dest_table_name); + } + ifaces_[i]->exchange_partitions(_return, partitionSpecs, source_db, source_table_name, dest_db, dest_table_name); + return; + } + + void get_partition_with_auth(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const std::string& user_name, const std::vector & group_names) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partition_with_auth(_return, db_name, tbl_name, part_vals, user_name, group_names); + } + ifaces_[i]->get_partition_with_auth(_return, db_name, tbl_name, part_vals, user_name, group_names); + return; + } + + void get_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partition_by_name(_return, db_name, tbl_name, part_name); + } + ifaces_[i]->get_partition_by_name(_return, db_name, tbl_name, part_name); + return; + } + + void get_partitions(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partitions(_return, db_name, tbl_name, max_parts); + } + ifaces_[i]->get_partitions(_return, db_name, tbl_name, max_parts); + return; + } + + void get_partitions_req(PartitionsResponse& _return, const PartitionsRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partitions_req(_return, req); + } + ifaces_[i]->get_partitions_req(_return, req); + return; + } + + void get_partitions_with_auth(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts, const std::string& user_name, const std::vector & group_names) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partitions_with_auth(_return, db_name, tbl_name, max_parts, user_name, group_names); + } + ifaces_[i]->get_partitions_with_auth(_return, db_name, tbl_name, max_parts, user_name, group_names); + return; + } + + void get_partitions_pspec(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int32_t max_parts) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partitions_pspec(_return, db_name, tbl_name, max_parts); + } + ifaces_[i]->get_partitions_pspec(_return, db_name, tbl_name, max_parts); + return; + } + + void get_partition_names(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partition_names(_return, db_name, tbl_name, max_parts); + } + ifaces_[i]->get_partition_names(_return, db_name, tbl_name, max_parts); + return; + } + + void fetch_partition_names_req(std::vector & _return, const PartitionsRequest& partitionReq) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->fetch_partition_names_req(_return, partitionReq); + } + ifaces_[i]->fetch_partition_names_req(_return, partitionReq); + return; + } + + void get_partition_values(PartitionValuesResponse& _return, const PartitionValuesRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partition_values(_return, request); + } + ifaces_[i]->get_partition_values(_return, request); + return; + } + + void get_partitions_ps(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partitions_ps(_return, db_name, tbl_name, part_vals, max_parts); + } + ifaces_[i]->get_partitions_ps(_return, db_name, tbl_name, part_vals, max_parts); + return; + } + + void get_partitions_ps_with_auth(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts, const std::string& user_name, const std::vector & group_names) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partitions_ps_with_auth(_return, db_name, tbl_name, part_vals, max_parts, user_name, group_names); + } + ifaces_[i]->get_partitions_ps_with_auth(_return, db_name, tbl_name, part_vals, max_parts, user_name, group_names); + return; + } + + void get_partitions_ps_with_auth_req(GetPartitionsPsWithAuthResponse& _return, const GetPartitionsPsWithAuthRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partitions_ps_with_auth_req(_return, req); + } + ifaces_[i]->get_partitions_ps_with_auth_req(_return, req); + return; + } + + void get_partition_names_ps(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partition_names_ps(_return, db_name, tbl_name, part_vals, max_parts); + } + ifaces_[i]->get_partition_names_ps(_return, db_name, tbl_name, part_vals, max_parts); + return; + } + + void get_partition_names_ps_req(GetPartitionNamesPsResponse& _return, const GetPartitionNamesPsRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partition_names_ps_req(_return, req); + } + ifaces_[i]->get_partition_names_ps_req(_return, req); + return; + } + + void get_partition_names_req(std::vector & _return, const PartitionsByExprRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partition_names_req(_return, req); + } + ifaces_[i]->get_partition_names_req(_return, req); + return; + } + + void get_partitions_by_filter(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int16_t max_parts) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partitions_by_filter(_return, db_name, tbl_name, filter, max_parts); + } + ifaces_[i]->get_partitions_by_filter(_return, db_name, tbl_name, filter, max_parts); + return; + } + + void get_partitions_by_filter_req(std::vector & _return, const GetPartitionsByFilterRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partitions_by_filter_req(_return, req); + } + ifaces_[i]->get_partitions_by_filter_req(_return, req); + return; + } + + void get_part_specs_by_filter(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int32_t max_parts) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_part_specs_by_filter(_return, db_name, tbl_name, filter, max_parts); + } + ifaces_[i]->get_part_specs_by_filter(_return, db_name, tbl_name, filter, max_parts); + return; + } + + void get_partitions_by_expr(PartitionsByExprResult& _return, const PartitionsByExprRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partitions_by_expr(_return, req); + } + ifaces_[i]->get_partitions_by_expr(_return, req); + return; + } + + void get_partitions_spec_by_expr(PartitionsSpecByExprResult& _return, const PartitionsByExprRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partitions_spec_by_expr(_return, req); + } + ifaces_[i]->get_partitions_spec_by_expr(_return, req); + return; + } + + int32_t get_num_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_num_partitions_by_filter(db_name, tbl_name, filter); + } + return ifaces_[i]->get_num_partitions_by_filter(db_name, tbl_name, filter); + } + + void get_partitions_by_names(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & names) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partitions_by_names(_return, db_name, tbl_name, names); + } + ifaces_[i]->get_partitions_by_names(_return, db_name, tbl_name, names); + return; + } + + void get_partitions_by_names_req(GetPartitionsByNamesResult& _return, const GetPartitionsByNamesRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partitions_by_names_req(_return, req); + } + ifaces_[i]->get_partitions_by_names_req(_return, req); + return; + } + + void get_properties(PropertyGetResponse& _return, const PropertyGetRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_properties(_return, req); + } + ifaces_[i]->get_properties(_return, req); + return; + } + + bool set_properties(const PropertySetRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->set_properties(req); + } + return ifaces_[i]->set_properties(req); + } + + void alter_partition(const std::string& db_name, const std::string& tbl_name, const Partition& new_part) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->alter_partition(db_name, tbl_name, new_part); + } + ifaces_[i]->alter_partition(db_name, tbl_name, new_part); + } + + void alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->alter_partitions(db_name, tbl_name, new_parts); + } + ifaces_[i]->alter_partitions(db_name, tbl_name, new_parts); + } + + void alter_partitions_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts, const EnvironmentContext& environment_context) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->alter_partitions_with_environment_context(db_name, tbl_name, new_parts, environment_context); + } + ifaces_[i]->alter_partitions_with_environment_context(db_name, tbl_name, new_parts, environment_context); + } + + void alter_partitions_req(AlterPartitionsResponse& _return, const AlterPartitionsRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->alter_partitions_req(_return, req); + } + ifaces_[i]->alter_partitions_req(_return, req); + return; + } + + void alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->alter_partition_with_environment_context(db_name, tbl_name, new_part, environment_context); + } + ifaces_[i]->alter_partition_with_environment_context(db_name, tbl_name, new_part, environment_context); + } + + void rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const Partition& new_part) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->rename_partition(db_name, tbl_name, part_vals, new_part); + } + ifaces_[i]->rename_partition(db_name, tbl_name, part_vals, new_part); + } + + void rename_partition_req(RenamePartitionResponse& _return, const RenamePartitionRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->rename_partition_req(_return, req); + } + ifaces_[i]->rename_partition_req(_return, req); + return; + } + + bool partition_name_has_valid_characters(const std::vector & part_vals, const bool throw_exception) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->partition_name_has_valid_characters(part_vals, throw_exception); + } + return ifaces_[i]->partition_name_has_valid_characters(part_vals, throw_exception); + } + + void get_config_value(std::string& _return, const std::string& name, const std::string& defaultValue) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_config_value(_return, name, defaultValue); + } + ifaces_[i]->get_config_value(_return, name, defaultValue); + return; + } + + void partition_name_to_vals(std::vector & _return, const std::string& part_name) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->partition_name_to_vals(_return, part_name); + } + ifaces_[i]->partition_name_to_vals(_return, part_name); + return; + } + + void partition_name_to_spec(std::map & _return, const std::string& part_name) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->partition_name_to_spec(_return, part_name); + } + ifaces_[i]->partition_name_to_spec(_return, part_name); + return; + } + + void markPartitionForEvent(const std::string& db_name, const std::string& tbl_name, const std::map & part_vals, const PartitionEventType::type eventType) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->markPartitionForEvent(db_name, tbl_name, part_vals, eventType); + } + ifaces_[i]->markPartitionForEvent(db_name, tbl_name, part_vals, eventType); + } + + bool isPartitionMarkedForEvent(const std::string& db_name, const std::string& tbl_name, const std::map & part_vals, const PartitionEventType::type eventType) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->isPartitionMarkedForEvent(db_name, tbl_name, part_vals, eventType); + } + return ifaces_[i]->isPartitionMarkedForEvent(db_name, tbl_name, part_vals, eventType); + } + + void get_primary_keys(PrimaryKeysResponse& _return, const PrimaryKeysRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_primary_keys(_return, request); + } + ifaces_[i]->get_primary_keys(_return, request); + return; + } + + void get_foreign_keys(ForeignKeysResponse& _return, const ForeignKeysRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_foreign_keys(_return, request); + } + ifaces_[i]->get_foreign_keys(_return, request); + return; + } + + void get_unique_constraints(UniqueConstraintsResponse& _return, const UniqueConstraintsRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_unique_constraints(_return, request); + } + ifaces_[i]->get_unique_constraints(_return, request); + return; + } + + void get_not_null_constraints(NotNullConstraintsResponse& _return, const NotNullConstraintsRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_not_null_constraints(_return, request); + } + ifaces_[i]->get_not_null_constraints(_return, request); + return; + } + + void get_default_constraints(DefaultConstraintsResponse& _return, const DefaultConstraintsRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_default_constraints(_return, request); + } + ifaces_[i]->get_default_constraints(_return, request); + return; + } + + void get_check_constraints(CheckConstraintsResponse& _return, const CheckConstraintsRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_check_constraints(_return, request); + } + ifaces_[i]->get_check_constraints(_return, request); + return; + } + + void get_all_table_constraints(AllTableConstraintsResponse& _return, const AllTableConstraintsRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_all_table_constraints(_return, request); + } + ifaces_[i]->get_all_table_constraints(_return, request); + return; + } + + bool update_table_column_statistics(const ColumnStatistics& stats_obj) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->update_table_column_statistics(stats_obj); + } + return ifaces_[i]->update_table_column_statistics(stats_obj); + } + + bool update_partition_column_statistics(const ColumnStatistics& stats_obj) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->update_partition_column_statistics(stats_obj); + } + return ifaces_[i]->update_partition_column_statistics(stats_obj); + } + + void update_table_column_statistics_req(SetPartitionsStatsResponse& _return, const SetPartitionsStatsRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->update_table_column_statistics_req(_return, req); + } + ifaces_[i]->update_table_column_statistics_req(_return, req); + return; + } + + void update_partition_column_statistics_req(SetPartitionsStatsResponse& _return, const SetPartitionsStatsRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->update_partition_column_statistics_req(_return, req); + } + ifaces_[i]->update_partition_column_statistics_req(_return, req); + return; + } + + void update_transaction_statistics(const UpdateTransactionalStatsRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->update_transaction_statistics(req); + } + ifaces_[i]->update_transaction_statistics(req); + } + + void get_table_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& col_name) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_table_column_statistics(_return, db_name, tbl_name, col_name); + } + ifaces_[i]->get_table_column_statistics(_return, db_name, tbl_name, col_name); + return; + } + + void get_partition_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partition_column_statistics(_return, db_name, tbl_name, part_name, col_name); + } + ifaces_[i]->get_partition_column_statistics(_return, db_name, tbl_name, part_name, col_name); + return; + } + + void get_table_statistics_req(TableStatsResult& _return, const TableStatsRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_table_statistics_req(_return, request); + } + ifaces_[i]->get_table_statistics_req(_return, request); + return; + } + + void get_partitions_statistics_req(PartitionsStatsResult& _return, const PartitionsStatsRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partitions_statistics_req(_return, request); + } + ifaces_[i]->get_partitions_statistics_req(_return, request); + return; + } + + void get_aggr_stats_for(AggrStats& _return, const PartitionsStatsRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_aggr_stats_for(_return, request); + } + ifaces_[i]->get_aggr_stats_for(_return, request); + return; + } + + bool set_aggr_stats_for(const SetPartitionsStatsRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->set_aggr_stats_for(request); + } + return ifaces_[i]->set_aggr_stats_for(request); + } + + bool delete_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name, const std::string& engine) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->delete_partition_column_statistics(db_name, tbl_name, part_name, col_name, engine); + } + return ifaces_[i]->delete_partition_column_statistics(db_name, tbl_name, part_name, col_name, engine); + } + + bool delete_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name, const std::string& engine) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->delete_table_column_statistics(db_name, tbl_name, col_name, engine); + } + return ifaces_[i]->delete_table_column_statistics(db_name, tbl_name, col_name, engine); + } + + void create_function(const Function& func) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->create_function(func); + } + ifaces_[i]->create_function(func); + } + + void drop_function(const std::string& dbName, const std::string& funcName) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_function(dbName, funcName); + } + ifaces_[i]->drop_function(dbName, funcName); + } + + void alter_function(const std::string& dbName, const std::string& funcName, const Function& newFunc) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->alter_function(dbName, funcName, newFunc); + } + ifaces_[i]->alter_function(dbName, funcName, newFunc); + } + + void get_functions(std::vector & _return, const std::string& dbName, const std::string& pattern) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_functions(_return, dbName, pattern); + } + ifaces_[i]->get_functions(_return, dbName, pattern); + return; + } + + void get_function(Function& _return, const std::string& dbName, const std::string& funcName) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_function(_return, dbName, funcName); + } + ifaces_[i]->get_function(_return, dbName, funcName); + return; + } + + void get_all_functions(GetAllFunctionsResponse& _return) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_all_functions(_return); + } + ifaces_[i]->get_all_functions(_return); + return; + } + + bool create_role(const Role& role) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->create_role(role); + } + return ifaces_[i]->create_role(role); + } + + bool drop_role(const std::string& role_name) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_role(role_name); + } + return ifaces_[i]->drop_role(role_name); + } + + void get_role_names(std::vector & _return) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_role_names(_return); + } + ifaces_[i]->get_role_names(_return); + return; + } + + bool grant_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type, const std::string& grantor, const PrincipalType::type grantorType, const bool grant_option) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->grant_role(role_name, principal_name, principal_type, grantor, grantorType, grant_option); + } + return ifaces_[i]->grant_role(role_name, principal_name, principal_type, grantor, grantorType, grant_option); + } + + bool revoke_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->revoke_role(role_name, principal_name, principal_type); + } + return ifaces_[i]->revoke_role(role_name, principal_name, principal_type); + } + + void list_roles(std::vector & _return, const std::string& principal_name, const PrincipalType::type principal_type) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->list_roles(_return, principal_name, principal_type); + } + ifaces_[i]->list_roles(_return, principal_name, principal_type); + return; + } + + void grant_revoke_role(GrantRevokeRoleResponse& _return, const GrantRevokeRoleRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->grant_revoke_role(_return, request); + } + ifaces_[i]->grant_revoke_role(_return, request); + return; + } + + void get_principals_in_role(GetPrincipalsInRoleResponse& _return, const GetPrincipalsInRoleRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_principals_in_role(_return, request); + } + ifaces_[i]->get_principals_in_role(_return, request); + return; + } + + void get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& _return, const GetRoleGrantsForPrincipalRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_role_grants_for_principal(_return, request); + } + ifaces_[i]->get_role_grants_for_principal(_return, request); + return; + } + + void get_privilege_set(PrincipalPrivilegeSet& _return, const HiveObjectRef& hiveObject, const std::string& user_name, const std::vector & group_names) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_privilege_set(_return, hiveObject, user_name, group_names); + } + ifaces_[i]->get_privilege_set(_return, hiveObject, user_name, group_names); + return; + } + + void list_privileges(std::vector & _return, const std::string& principal_name, const PrincipalType::type principal_type, const HiveObjectRef& hiveObject) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->list_privileges(_return, principal_name, principal_type, hiveObject); + } + ifaces_[i]->list_privileges(_return, principal_name, principal_type, hiveObject); + return; + } + + bool grant_privileges(const PrivilegeBag& privileges) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->grant_privileges(privileges); + } + return ifaces_[i]->grant_privileges(privileges); + } + + bool revoke_privileges(const PrivilegeBag& privileges) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->revoke_privileges(privileges); + } + return ifaces_[i]->revoke_privileges(privileges); + } + + void grant_revoke_privileges(GrantRevokePrivilegeResponse& _return, const GrantRevokePrivilegeRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->grant_revoke_privileges(_return, request); + } + ifaces_[i]->grant_revoke_privileges(_return, request); + return; + } + + void refresh_privileges(GrantRevokePrivilegeResponse& _return, const HiveObjectRef& objToRefresh, const std::string& authorizer, const GrantRevokePrivilegeRequest& grantRequest) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->refresh_privileges(_return, objToRefresh, authorizer, grantRequest); + } + ifaces_[i]->refresh_privileges(_return, objToRefresh, authorizer, grantRequest); + return; + } + + void set_ugi(std::vector & _return, const std::string& user_name, const std::vector & group_names) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->set_ugi(_return, user_name, group_names); + } + ifaces_[i]->set_ugi(_return, user_name, group_names); + return; + } + + void get_delegation_token(std::string& _return, const std::string& token_owner, const std::string& renewer_kerberos_principal_name) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_delegation_token(_return, token_owner, renewer_kerberos_principal_name); + } + ifaces_[i]->get_delegation_token(_return, token_owner, renewer_kerberos_principal_name); + return; + } + + int64_t renew_delegation_token(const std::string& token_str_form) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->renew_delegation_token(token_str_form); + } + return ifaces_[i]->renew_delegation_token(token_str_form); + } + + void cancel_delegation_token(const std::string& token_str_form) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->cancel_delegation_token(token_str_form); + } + ifaces_[i]->cancel_delegation_token(token_str_form); + } + + bool add_token(const std::string& token_identifier, const std::string& delegation_token) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_token(token_identifier, delegation_token); + } + return ifaces_[i]->add_token(token_identifier, delegation_token); + } + + bool remove_token(const std::string& token_identifier) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->remove_token(token_identifier); + } + return ifaces_[i]->remove_token(token_identifier); + } + + void get_token(std::string& _return, const std::string& token_identifier) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_token(_return, token_identifier); + } + ifaces_[i]->get_token(_return, token_identifier); + return; + } + + void get_all_token_identifiers(std::vector & _return) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_all_token_identifiers(_return); + } + ifaces_[i]->get_all_token_identifiers(_return); + return; + } + + int32_t add_master_key(const std::string& key) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_master_key(key); + } + return ifaces_[i]->add_master_key(key); + } + + void update_master_key(const int32_t seq_number, const std::string& key) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->update_master_key(seq_number, key); + } + ifaces_[i]->update_master_key(seq_number, key); + } + + bool remove_master_key(const int32_t key_seq) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->remove_master_key(key_seq); + } + return ifaces_[i]->remove_master_key(key_seq); + } + + void get_master_keys(std::vector & _return) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_master_keys(_return); + } + ifaces_[i]->get_master_keys(_return); + return; + } + + void get_open_txns(GetOpenTxnsResponse& _return) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_open_txns(_return); + } + ifaces_[i]->get_open_txns(_return); + return; + } + + void get_open_txns_info(GetOpenTxnsInfoResponse& _return) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_open_txns_info(_return); + } + ifaces_[i]->get_open_txns_info(_return); + return; + } + + void open_txns(OpenTxnsResponse& _return, const OpenTxnRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->open_txns(_return, rqst); + } + ifaces_[i]->open_txns(_return, rqst); + return; + } + + void abort_txn(const AbortTxnRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->abort_txn(rqst); + } + ifaces_[i]->abort_txn(rqst); + } + + void abort_txns(const AbortTxnsRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->abort_txns(rqst); + } + ifaces_[i]->abort_txns(rqst); + } + + void commit_txn(const CommitTxnRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->commit_txn(rqst); + } + ifaces_[i]->commit_txn(rqst); + } + + int64_t get_latest_txnid_in_conflict(const int64_t txnId) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_latest_txnid_in_conflict(txnId); + } + return ifaces_[i]->get_latest_txnid_in_conflict(txnId); + } + + void repl_tbl_writeid_state(const ReplTblWriteIdStateRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->repl_tbl_writeid_state(rqst); + } + ifaces_[i]->repl_tbl_writeid_state(rqst); + } + + void get_valid_write_ids(GetValidWriteIdsResponse& _return, const GetValidWriteIdsRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_valid_write_ids(_return, rqst); + } + ifaces_[i]->get_valid_write_ids(_return, rqst); + return; + } + + void add_write_ids_to_min_history(const int64_t txnId, const std::map & writeIds) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_write_ids_to_min_history(txnId, writeIds); + } + ifaces_[i]->add_write_ids_to_min_history(txnId, writeIds); + } + + void allocate_table_write_ids(AllocateTableWriteIdsResponse& _return, const AllocateTableWriteIdsRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->allocate_table_write_ids(_return, rqst); + } + ifaces_[i]->allocate_table_write_ids(_return, rqst); + return; + } + + void get_max_allocated_table_write_id(MaxAllocatedTableWriteIdResponse& _return, const MaxAllocatedTableWriteIdRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_max_allocated_table_write_id(_return, rqst); + } + ifaces_[i]->get_max_allocated_table_write_id(_return, rqst); + return; + } + + void seed_write_id(const SeedTableWriteIdsRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->seed_write_id(rqst); + } + ifaces_[i]->seed_write_id(rqst); + } + + void seed_txn_id(const SeedTxnIdRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->seed_txn_id(rqst); + } + ifaces_[i]->seed_txn_id(rqst); + } + + void lock(LockResponse& _return, const LockRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->lock(_return, rqst); + } + ifaces_[i]->lock(_return, rqst); + return; + } + + void check_lock(LockResponse& _return, const CheckLockRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->check_lock(_return, rqst); + } + ifaces_[i]->check_lock(_return, rqst); + return; + } + + void unlock(const UnlockRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->unlock(rqst); + } + ifaces_[i]->unlock(rqst); + } + + void show_locks(ShowLocksResponse& _return, const ShowLocksRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->show_locks(_return, rqst); + } + ifaces_[i]->show_locks(_return, rqst); + return; + } + + void heartbeat(const HeartbeatRequest& ids) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->heartbeat(ids); + } + ifaces_[i]->heartbeat(ids); + } + + void heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const HeartbeatTxnRangeRequest& txns) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->heartbeat_txn_range(_return, txns); + } + ifaces_[i]->heartbeat_txn_range(_return, txns); + return; + } + + void compact(const CompactionRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->compact(rqst); + } + ifaces_[i]->compact(rqst); + } + + void compact2(CompactionResponse& _return, const CompactionRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->compact2(_return, rqst); + } + ifaces_[i]->compact2(_return, rqst); + return; + } + + void show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->show_compact(_return, rqst); + } + ifaces_[i]->show_compact(_return, rqst); + return; + } + + bool submit_for_cleanup(const CompactionRequest& o1, const int64_t o2, const int64_t o3) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->submit_for_cleanup(o1, o2, o3); + } + return ifaces_[i]->submit_for_cleanup(o1, o2, o3); + } + + void add_dynamic_partitions(const AddDynamicPartitions& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_dynamic_partitions(rqst); + } + ifaces_[i]->add_dynamic_partitions(rqst); + } + + void find_next_compact(OptionalCompactionInfoStruct& _return, const std::string& workerId) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->find_next_compact(_return, workerId); + } + ifaces_[i]->find_next_compact(_return, workerId); + return; + } + + void find_next_compact2(OptionalCompactionInfoStruct& _return, const FindNextCompactRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->find_next_compact2(_return, rqst); + } + ifaces_[i]->find_next_compact2(_return, rqst); + return; + } + + void update_compactor_state(const CompactionInfoStruct& cr, const int64_t txn_id) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->update_compactor_state(cr, txn_id); + } + ifaces_[i]->update_compactor_state(cr, txn_id); + } + + void find_columns_with_stats(std::vector & _return, const CompactionInfoStruct& cr) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->find_columns_with_stats(_return, cr); + } + ifaces_[i]->find_columns_with_stats(_return, cr); + return; + } + + void mark_cleaned(const CompactionInfoStruct& cr) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->mark_cleaned(cr); + } + ifaces_[i]->mark_cleaned(cr); + } + + void mark_compacted(const CompactionInfoStruct& cr) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->mark_compacted(cr); + } + ifaces_[i]->mark_compacted(cr); + } + + void mark_failed(const CompactionInfoStruct& cr) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->mark_failed(cr); + } + ifaces_[i]->mark_failed(cr); + } + + void mark_refused(const CompactionInfoStruct& cr) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->mark_refused(cr); + } + ifaces_[i]->mark_refused(cr); + } + + bool update_compaction_metrics_data(const CompactionMetricsDataStruct& data) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->update_compaction_metrics_data(data); + } + return ifaces_[i]->update_compaction_metrics_data(data); + } + + void remove_compaction_metrics_data(const CompactionMetricsDataRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->remove_compaction_metrics_data(request); + } + ifaces_[i]->remove_compaction_metrics_data(request); + } + + void set_hadoop_jobid(const std::string& jobId, const int64_t cq_id) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->set_hadoop_jobid(jobId, cq_id); + } + ifaces_[i]->set_hadoop_jobid(jobId, cq_id); + } + + void get_latest_committed_compaction_info(GetLatestCommittedCompactionInfoResponse& _return, const GetLatestCommittedCompactionInfoRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_latest_committed_compaction_info(_return, rqst); + } + ifaces_[i]->get_latest_committed_compaction_info(_return, rqst); + return; + } + + void get_next_notification(NotificationEventResponse& _return, const NotificationEventRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_next_notification(_return, rqst); + } + ifaces_[i]->get_next_notification(_return, rqst); + return; + } + + void get_current_notificationEventId(CurrentNotificationEventId& _return) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_current_notificationEventId(_return); + } + ifaces_[i]->get_current_notificationEventId(_return); + return; + } + + void get_notification_events_count(NotificationEventsCountResponse& _return, const NotificationEventsCountRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_notification_events_count(_return, rqst); + } + ifaces_[i]->get_notification_events_count(_return, rqst); + return; + } + + void fire_listener_event(FireEventResponse& _return, const FireEventRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->fire_listener_event(_return, rqst); + } + ifaces_[i]->fire_listener_event(_return, rqst); + return; + } + + void flushCache() override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->flushCache(); + } + ifaces_[i]->flushCache(); + } + + void add_write_notification_log(WriteNotificationLogResponse& _return, const WriteNotificationLogRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_write_notification_log(_return, rqst); + } + ifaces_[i]->add_write_notification_log(_return, rqst); + return; + } + + void add_write_notification_log_in_batch(WriteNotificationLogBatchResponse& _return, const WriteNotificationLogBatchRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_write_notification_log_in_batch(_return, rqst); + } + ifaces_[i]->add_write_notification_log_in_batch(_return, rqst); + return; + } + + void cm_recycle(CmRecycleResponse& _return, const CmRecycleRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->cm_recycle(_return, request); + } + ifaces_[i]->cm_recycle(_return, request); + return; + } + + void get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_file_metadata_by_expr(_return, req); + } + ifaces_[i]->get_file_metadata_by_expr(_return, req); + return; + } + + void get_file_metadata(GetFileMetadataResult& _return, const GetFileMetadataRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_file_metadata(_return, req); + } + ifaces_[i]->get_file_metadata(_return, req); + return; + } + + void put_file_metadata(PutFileMetadataResult& _return, const PutFileMetadataRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->put_file_metadata(_return, req); + } + ifaces_[i]->put_file_metadata(_return, req); + return; + } + + void clear_file_metadata(ClearFileMetadataResult& _return, const ClearFileMetadataRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->clear_file_metadata(_return, req); + } + ifaces_[i]->clear_file_metadata(_return, req); + return; + } + + void cache_file_metadata(CacheFileMetadataResult& _return, const CacheFileMetadataRequest& req) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->cache_file_metadata(_return, req); + } + ifaces_[i]->cache_file_metadata(_return, req); + return; + } + + void get_metastore_db_uuid(std::string& _return) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_metastore_db_uuid(_return); + } + ifaces_[i]->get_metastore_db_uuid(_return); + return; + } + + void create_resource_plan(WMCreateResourcePlanResponse& _return, const WMCreateResourcePlanRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->create_resource_plan(_return, request); + } + ifaces_[i]->create_resource_plan(_return, request); + return; + } + + void get_resource_plan(WMGetResourcePlanResponse& _return, const WMGetResourcePlanRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_resource_plan(_return, request); + } + ifaces_[i]->get_resource_plan(_return, request); + return; + } + + void get_active_resource_plan(WMGetActiveResourcePlanResponse& _return, const WMGetActiveResourcePlanRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_active_resource_plan(_return, request); + } + ifaces_[i]->get_active_resource_plan(_return, request); + return; + } + + void get_all_resource_plans(WMGetAllResourcePlanResponse& _return, const WMGetAllResourcePlanRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_all_resource_plans(_return, request); + } + ifaces_[i]->get_all_resource_plans(_return, request); + return; + } + + void alter_resource_plan(WMAlterResourcePlanResponse& _return, const WMAlterResourcePlanRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->alter_resource_plan(_return, request); + } + ifaces_[i]->alter_resource_plan(_return, request); + return; + } + + void validate_resource_plan(WMValidateResourcePlanResponse& _return, const WMValidateResourcePlanRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->validate_resource_plan(_return, request); + } + ifaces_[i]->validate_resource_plan(_return, request); + return; + } + + void drop_resource_plan(WMDropResourcePlanResponse& _return, const WMDropResourcePlanRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_resource_plan(_return, request); + } + ifaces_[i]->drop_resource_plan(_return, request); + return; + } + + void create_wm_trigger(WMCreateTriggerResponse& _return, const WMCreateTriggerRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->create_wm_trigger(_return, request); + } + ifaces_[i]->create_wm_trigger(_return, request); + return; + } + + void alter_wm_trigger(WMAlterTriggerResponse& _return, const WMAlterTriggerRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->alter_wm_trigger(_return, request); + } + ifaces_[i]->alter_wm_trigger(_return, request); + return; + } + + void drop_wm_trigger(WMDropTriggerResponse& _return, const WMDropTriggerRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_wm_trigger(_return, request); + } + ifaces_[i]->drop_wm_trigger(_return, request); + return; + } + + void get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const WMGetTriggersForResourePlanRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_triggers_for_resourceplan(_return, request); + } + ifaces_[i]->get_triggers_for_resourceplan(_return, request); + return; + } + + void create_wm_pool(WMCreatePoolResponse& _return, const WMCreatePoolRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->create_wm_pool(_return, request); + } + ifaces_[i]->create_wm_pool(_return, request); + return; + } + + void alter_wm_pool(WMAlterPoolResponse& _return, const WMAlterPoolRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->alter_wm_pool(_return, request); + } + ifaces_[i]->alter_wm_pool(_return, request); + return; + } + + void drop_wm_pool(WMDropPoolResponse& _return, const WMDropPoolRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_wm_pool(_return, request); + } + ifaces_[i]->drop_wm_pool(_return, request); + return; + } + + void create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const WMCreateOrUpdateMappingRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->create_or_update_wm_mapping(_return, request); + } + ifaces_[i]->create_or_update_wm_mapping(_return, request); + return; + } + + void drop_wm_mapping(WMDropMappingResponse& _return, const WMDropMappingRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_wm_mapping(_return, request); + } + ifaces_[i]->drop_wm_mapping(_return, request); + return; + } + + void create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return, const WMCreateOrDropTriggerToPoolMappingRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->create_or_drop_wm_trigger_to_pool_mapping(_return, request); + } + ifaces_[i]->create_or_drop_wm_trigger_to_pool_mapping(_return, request); + return; + } + + void create_ischema(const ISchema& schema) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->create_ischema(schema); + } + ifaces_[i]->create_ischema(schema); + } + + void alter_ischema(const AlterISchemaRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->alter_ischema(rqst); + } + ifaces_[i]->alter_ischema(rqst); + } + + void get_ischema(ISchema& _return, const ISchemaName& name) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_ischema(_return, name); + } + ifaces_[i]->get_ischema(_return, name); + return; + } + + void drop_ischema(const ISchemaName& name) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_ischema(name); + } + ifaces_[i]->drop_ischema(name); + } + + void add_schema_version(const SchemaVersion& schemaVersion) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_schema_version(schemaVersion); + } + ifaces_[i]->add_schema_version(schemaVersion); + } + + void get_schema_version(SchemaVersion& _return, const SchemaVersionDescriptor& schemaVersion) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_schema_version(_return, schemaVersion); + } + ifaces_[i]->get_schema_version(_return, schemaVersion); + return; + } + + void get_schema_latest_version(SchemaVersion& _return, const ISchemaName& schemaName) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_schema_latest_version(_return, schemaName); + } + ifaces_[i]->get_schema_latest_version(_return, schemaName); + return; + } + + void get_schema_all_versions(std::vector & _return, const ISchemaName& schemaName) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_schema_all_versions(_return, schemaName); + } + ifaces_[i]->get_schema_all_versions(_return, schemaName); + return; + } + + void drop_schema_version(const SchemaVersionDescriptor& schemaVersion) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_schema_version(schemaVersion); + } + ifaces_[i]->drop_schema_version(schemaVersion); + } + + void get_schemas_by_cols(FindSchemasByColsResp& _return, const FindSchemasByColsRqst& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_schemas_by_cols(_return, rqst); + } + ifaces_[i]->get_schemas_by_cols(_return, rqst); + return; + } + + void map_schema_version_to_serde(const MapSchemaVersionToSerdeRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->map_schema_version_to_serde(rqst); + } + ifaces_[i]->map_schema_version_to_serde(rqst); + } + + void set_schema_version_state(const SetSchemaVersionStateRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->set_schema_version_state(rqst); + } + ifaces_[i]->set_schema_version_state(rqst); + } + + void add_serde(const SerDeInfo& serde) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_serde(serde); + } + ifaces_[i]->add_serde(serde); + } + + void get_serde(SerDeInfo& _return, const GetSerdeRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_serde(_return, rqst); + } + ifaces_[i]->get_serde(_return, rqst); + return; + } + + void get_lock_materialization_rebuild(LockResponse& _return, const std::string& dbName, const std::string& tableName, const int64_t txnId) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_lock_materialization_rebuild(_return, dbName, tableName, txnId); + } + ifaces_[i]->get_lock_materialization_rebuild(_return, dbName, tableName, txnId); + return; + } + + bool heartbeat_lock_materialization_rebuild(const std::string& dbName, const std::string& tableName, const int64_t txnId) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->heartbeat_lock_materialization_rebuild(dbName, tableName, txnId); + } + return ifaces_[i]->heartbeat_lock_materialization_rebuild(dbName, tableName, txnId); + } + + void add_runtime_stats(const RuntimeStat& stat) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_runtime_stats(stat); + } + ifaces_[i]->add_runtime_stats(stat); + } + + void get_runtime_stats(std::vector & _return, const GetRuntimeStatsRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_runtime_stats(_return, rqst); + } + ifaces_[i]->get_runtime_stats(_return, rqst); + return; + } + + void get_partitions_with_specs(GetPartitionsResponse& _return, const GetPartitionsRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_partitions_with_specs(_return, request); + } + ifaces_[i]->get_partitions_with_specs(_return, request); + return; + } + + void scheduled_query_poll(ScheduledQueryPollResponse& _return, const ScheduledQueryPollRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->scheduled_query_poll(_return, request); + } + ifaces_[i]->scheduled_query_poll(_return, request); + return; + } + + void scheduled_query_maintenance(const ScheduledQueryMaintenanceRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->scheduled_query_maintenance(request); + } + ifaces_[i]->scheduled_query_maintenance(request); + } + + void scheduled_query_progress(const ScheduledQueryProgressInfo& info) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->scheduled_query_progress(info); + } + ifaces_[i]->scheduled_query_progress(info); + } + + void get_scheduled_query(ScheduledQuery& _return, const ScheduledQueryKey& scheduleKey) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_scheduled_query(_return, scheduleKey); + } + ifaces_[i]->get_scheduled_query(_return, scheduleKey); + return; + } + + void add_replication_metrics(const ReplicationMetricList& replicationMetricList) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_replication_metrics(replicationMetricList); + } + ifaces_[i]->add_replication_metrics(replicationMetricList); + } + + void get_replication_metrics(ReplicationMetricList& _return, const GetReplicationMetricsRequest& rqst) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_replication_metrics(_return, rqst); + } + ifaces_[i]->get_replication_metrics(_return, rqst); + return; + } + + void get_open_txns_req(GetOpenTxnsResponse& _return, const GetOpenTxnsRequest& getOpenTxnsRequest) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_open_txns_req(_return, getOpenTxnsRequest); + } + ifaces_[i]->get_open_txns_req(_return, getOpenTxnsRequest); + return; + } + + void create_stored_procedure(const StoredProcedure& proc) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->create_stored_procedure(proc); + } + ifaces_[i]->create_stored_procedure(proc); + } + + void get_stored_procedure(StoredProcedure& _return, const StoredProcedureRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_stored_procedure(_return, request); + } + ifaces_[i]->get_stored_procedure(_return, request); + return; + } + + void drop_stored_procedure(const StoredProcedureRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_stored_procedure(request); + } + ifaces_[i]->drop_stored_procedure(request); + } + + void get_all_stored_procedures(std::vector & _return, const ListStoredProcedureRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_all_stored_procedures(_return, request); + } + ifaces_[i]->get_all_stored_procedures(_return, request); + return; + } + + void find_package(Package& _return, const GetPackageRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->find_package(_return, request); + } + ifaces_[i]->find_package(_return, request); + return; + } + + void add_package(const AddPackageRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_package(request); + } + ifaces_[i]->add_package(request); + } + + void get_all_packages(std::vector & _return, const ListPackageRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_all_packages(_return, request); + } + ifaces_[i]->get_all_packages(_return, request); + return; + } + + void drop_package(const DropPackageRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_package(request); + } + ifaces_[i]->drop_package(request); + } + + void get_all_write_event_info(std::vector & _return, const GetAllWriteEventInfoRequest& request) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_all_write_event_info(_return, request); + } + ifaces_[i]->get_all_write_event_info(_return, request); + return; + } + +}; + +// The 'concurrent' client is a thread safe client that correctly handles +// out of order responses. It is slower than the regular client, so should +// only be used when you need to share a connection among multiple threads +class ThriftHiveMetastoreConcurrentClient : virtual public ThriftHiveMetastoreIf, public ::facebook::fb303::FacebookServiceConcurrentClient { + public: + ThriftHiveMetastoreConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot, std::shared_ptr< ::apache::thrift::async::TConcurrentClientSyncInfo> sync) : + ::facebook::fb303::FacebookServiceConcurrentClient(prot, prot, sync) {} + ThriftHiveMetastoreConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot, std::shared_ptr< ::apache::thrift::async::TConcurrentClientSyncInfo> sync) : ::facebook::fb303::FacebookServiceConcurrentClient(iprot, oprot, sync) {} + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + void abort_Compactions(AbortCompactResponse& _return, const AbortCompactionRequest& rqst) override; + int32_t send_abort_Compactions(const AbortCompactionRequest& rqst); + void recv_abort_Compactions(AbortCompactResponse& _return, const int32_t seqid); + void getMetaConf(std::string& _return, const std::string& key) override; + int32_t send_getMetaConf(const std::string& key); + void recv_getMetaConf(std::string& _return, const int32_t seqid); + void setMetaConf(const std::string& key, const std::string& value) override; + int32_t send_setMetaConf(const std::string& key, const std::string& value); + void recv_setMetaConf(const int32_t seqid); + void create_catalog(const CreateCatalogRequest& catalog) override; + int32_t send_create_catalog(const CreateCatalogRequest& catalog); + void recv_create_catalog(const int32_t seqid); + void alter_catalog(const AlterCatalogRequest& rqst) override; + int32_t send_alter_catalog(const AlterCatalogRequest& rqst); + void recv_alter_catalog(const int32_t seqid); + void get_catalog(GetCatalogResponse& _return, const GetCatalogRequest& catName) override; + int32_t send_get_catalog(const GetCatalogRequest& catName); + void recv_get_catalog(GetCatalogResponse& _return, const int32_t seqid); + void get_catalogs(GetCatalogsResponse& _return) override; + int32_t send_get_catalogs(); + void recv_get_catalogs(GetCatalogsResponse& _return, const int32_t seqid); + void drop_catalog(const DropCatalogRequest& catName) override; + int32_t send_drop_catalog(const DropCatalogRequest& catName); + void recv_drop_catalog(const int32_t seqid); + void create_database(const Database& database) override; + int32_t send_create_database(const Database& database); + void recv_create_database(const int32_t seqid); + void create_database_req(const CreateDatabaseRequest& createDatabaseRequest) override; + int32_t send_create_database_req(const CreateDatabaseRequest& createDatabaseRequest); + void recv_create_database_req(const int32_t seqid); + void get_database(Database& _return, const std::string& name) override; + int32_t send_get_database(const std::string& name); + void recv_get_database(Database& _return, const int32_t seqid); + void get_database_req(Database& _return, const GetDatabaseRequest& request) override; + int32_t send_get_database_req(const GetDatabaseRequest& request); + void recv_get_database_req(Database& _return, const int32_t seqid); + void drop_database(const std::string& name, const bool deleteData, const bool cascade) override; + int32_t send_drop_database(const std::string& name, const bool deleteData, const bool cascade); + void recv_drop_database(const int32_t seqid); + void drop_database_req(const DropDatabaseRequest& req) override; + int32_t send_drop_database_req(const DropDatabaseRequest& req); + void recv_drop_database_req(const int32_t seqid); + void get_databases(std::vector & _return, const std::string& pattern) override; + int32_t send_get_databases(const std::string& pattern); + void recv_get_databases(std::vector & _return, const int32_t seqid); + void get_all_databases(std::vector & _return) override; + int32_t send_get_all_databases(); + void recv_get_all_databases(std::vector & _return, const int32_t seqid); + void alter_database(const std::string& dbname, const Database& db) override; + int32_t send_alter_database(const std::string& dbname, const Database& db); + void recv_alter_database(const int32_t seqid); + void alter_database_req(const AlterDatabaseRequest& alterDbReq) override; + int32_t send_alter_database_req(const AlterDatabaseRequest& alterDbReq); + void recv_alter_database_req(const int32_t seqid); + void create_dataconnector_req(const CreateDataConnectorRequest& connectorReq) override; + int32_t send_create_dataconnector_req(const CreateDataConnectorRequest& connectorReq); + void recv_create_dataconnector_req(const int32_t seqid); + void get_dataconnector_req(DataConnector& _return, const GetDataConnectorRequest& request) override; + int32_t send_get_dataconnector_req(const GetDataConnectorRequest& request); + void recv_get_dataconnector_req(DataConnector& _return, const int32_t seqid); + void drop_dataconnector_req(const DropDataConnectorRequest& dropDcReq) override; + int32_t send_drop_dataconnector_req(const DropDataConnectorRequest& dropDcReq); + void recv_drop_dataconnector_req(const int32_t seqid); + void get_dataconnectors(std::vector & _return) override; + int32_t send_get_dataconnectors(); + void recv_get_dataconnectors(std::vector & _return, const int32_t seqid); + void alter_dataconnector_req(const AlterDataConnectorRequest& alterReq) override; + int32_t send_alter_dataconnector_req(const AlterDataConnectorRequest& alterReq); + void recv_alter_dataconnector_req(const int32_t seqid); + void get_type(Type& _return, const std::string& name) override; + int32_t send_get_type(const std::string& name); + void recv_get_type(Type& _return, const int32_t seqid); + bool create_type(const Type& type) override; + int32_t send_create_type(const Type& type); + bool recv_create_type(const int32_t seqid); + bool drop_type(const std::string& type) override; + int32_t send_drop_type(const std::string& type); + bool recv_drop_type(const int32_t seqid); + void get_type_all(std::map & _return, const std::string& name) override; + int32_t send_get_type_all(const std::string& name); + void recv_get_type_all(std::map & _return, const int32_t seqid); + void get_fields(std::vector & _return, const std::string& db_name, const std::string& table_name) override; + int32_t send_get_fields(const std::string& db_name, const std::string& table_name); + void recv_get_fields(std::vector & _return, const int32_t seqid); + void get_fields_with_environment_context(std::vector & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) override; + int32_t send_get_fields_with_environment_context(const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context); + void recv_get_fields_with_environment_context(std::vector & _return, const int32_t seqid); + void get_fields_req(GetFieldsResponse& _return, const GetFieldsRequest& req) override; + int32_t send_get_fields_req(const GetFieldsRequest& req); + void recv_get_fields_req(GetFieldsResponse& _return, const int32_t seqid); + void get_schema(std::vector & _return, const std::string& db_name, const std::string& table_name) override; + int32_t send_get_schema(const std::string& db_name, const std::string& table_name); + void recv_get_schema(std::vector & _return, const int32_t seqid); + void get_schema_with_environment_context(std::vector & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) override; + int32_t send_get_schema_with_environment_context(const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context); + void recv_get_schema_with_environment_context(std::vector & _return, const int32_t seqid); + void get_schema_req(GetSchemaResponse& _return, const GetSchemaRequest& req) override; + int32_t send_get_schema_req(const GetSchemaRequest& req); + void recv_get_schema_req(GetSchemaResponse& _return, const int32_t seqid); + void create_table(const Table& tbl) override; + int32_t send_create_table(const Table& tbl); + void recv_create_table(const int32_t seqid); + void create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context) override; + int32_t send_create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context); + void recv_create_table_with_environment_context(const int32_t seqid); + void create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys, const std::vector & uniqueConstraints, const std::vector & notNullConstraints, const std::vector & defaultConstraints, const std::vector & checkConstraints) override; + int32_t send_create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys, const std::vector & uniqueConstraints, const std::vector & notNullConstraints, const std::vector & defaultConstraints, const std::vector & checkConstraints); + void recv_create_table_with_constraints(const int32_t seqid); + void create_table_req(const CreateTableRequest& request) override; + int32_t send_create_table_req(const CreateTableRequest& request); + void recv_create_table_req(const int32_t seqid); + void drop_constraint(const DropConstraintRequest& req) override; + int32_t send_drop_constraint(const DropConstraintRequest& req); + void recv_drop_constraint(const int32_t seqid); + void add_primary_key(const AddPrimaryKeyRequest& req) override; + int32_t send_add_primary_key(const AddPrimaryKeyRequest& req); + void recv_add_primary_key(const int32_t seqid); + void add_foreign_key(const AddForeignKeyRequest& req) override; + int32_t send_add_foreign_key(const AddForeignKeyRequest& req); + void recv_add_foreign_key(const int32_t seqid); + void add_unique_constraint(const AddUniqueConstraintRequest& req) override; + int32_t send_add_unique_constraint(const AddUniqueConstraintRequest& req); + void recv_add_unique_constraint(const int32_t seqid); + void add_not_null_constraint(const AddNotNullConstraintRequest& req) override; + int32_t send_add_not_null_constraint(const AddNotNullConstraintRequest& req); + void recv_add_not_null_constraint(const int32_t seqid); + void add_default_constraint(const AddDefaultConstraintRequest& req) override; + int32_t send_add_default_constraint(const AddDefaultConstraintRequest& req); + void recv_add_default_constraint(const int32_t seqid); + void add_check_constraint(const AddCheckConstraintRequest& req) override; + int32_t send_add_check_constraint(const AddCheckConstraintRequest& req); + void recv_add_check_constraint(const int32_t seqid); + void translate_table_dryrun(Table& _return, const CreateTableRequest& request) override; + int32_t send_translate_table_dryrun(const CreateTableRequest& request); + void recv_translate_table_dryrun(Table& _return, const int32_t seqid); + void drop_table(const std::string& dbname, const std::string& name, const bool deleteData) override; + int32_t send_drop_table(const std::string& dbname, const std::string& name, const bool deleteData); + void recv_drop_table(const int32_t seqid); + void drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context) override; + int32_t send_drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context); + void recv_drop_table_with_environment_context(const int32_t seqid); + void drop_table_req(const DropTableRequest& dropTableReq) override; + int32_t send_drop_table_req(const DropTableRequest& dropTableReq); + void recv_drop_table_req(const int32_t seqid); + void truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames) override; + int32_t send_truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames); + void recv_truncate_table(const int32_t seqid); + void truncate_table_req(TruncateTableResponse& _return, const TruncateTableRequest& req) override; + int32_t send_truncate_table_req(const TruncateTableRequest& req); + void recv_truncate_table_req(TruncateTableResponse& _return, const int32_t seqid); + void get_tables(std::vector & _return, const std::string& db_name, const std::string& pattern) override; + int32_t send_get_tables(const std::string& db_name, const std::string& pattern); + void recv_get_tables(std::vector & _return, const int32_t seqid); + void get_tables_by_type(std::vector & _return, const std::string& db_name, const std::string& pattern, const std::string& tableType) override; + int32_t send_get_tables_by_type(const std::string& db_name, const std::string& pattern, const std::string& tableType); + void recv_get_tables_by_type(std::vector & _return, const int32_t seqid); + void get_all_materialized_view_objects_for_rewriting(std::vector
& _return) override; + int32_t send_get_all_materialized_view_objects_for_rewriting(); + void recv_get_all_materialized_view_objects_for_rewriting(std::vector
& _return, const int32_t seqid); + void get_materialized_views_for_rewriting(std::vector & _return, const std::string& db_name) override; + int32_t send_get_materialized_views_for_rewriting(const std::string& db_name); + void recv_get_materialized_views_for_rewriting(std::vector & _return, const int32_t seqid); + void get_table_meta(std::vector & _return, const std::string& db_patterns, const std::string& tbl_patterns, const std::vector & tbl_types) override; + int32_t send_get_table_meta(const std::string& db_patterns, const std::string& tbl_patterns, const std::vector & tbl_types); + void recv_get_table_meta(std::vector & _return, const int32_t seqid); + void get_all_tables(std::vector & _return, const std::string& db_name) override; + int32_t send_get_all_tables(const std::string& db_name); + void recv_get_all_tables(std::vector & _return, const int32_t seqid); + void get_tables_ext(std::vector & _return, const GetTablesExtRequest& req) override; + int32_t send_get_tables_ext(const GetTablesExtRequest& req); + void recv_get_tables_ext(std::vector & _return, const int32_t seqid); + void get_table_req(GetTableResult& _return, const GetTableRequest& req) override; + int32_t send_get_table_req(const GetTableRequest& req); + void recv_get_table_req(GetTableResult& _return, const int32_t seqid); + void get_table_objects_by_name_req(GetTablesResult& _return, const GetTablesRequest& req) override; + int32_t send_get_table_objects_by_name_req(const GetTablesRequest& req); + void recv_get_table_objects_by_name_req(GetTablesResult& _return, const int32_t seqid); + void get_materialization_invalidation_info(Materialization& _return, const CreationMetadata& creation_metadata, const std::string& validTxnList) override; + int32_t send_get_materialization_invalidation_info(const CreationMetadata& creation_metadata, const std::string& validTxnList); + void recv_get_materialization_invalidation_info(Materialization& _return, const int32_t seqid); + void update_creation_metadata(const std::string& catName, const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata) override; + int32_t send_update_creation_metadata(const std::string& catName, const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata); + void recv_update_creation_metadata(const int32_t seqid); + void get_table_names_by_filter(std::vector & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables) override; + int32_t send_get_table_names_by_filter(const std::string& dbname, const std::string& filter, const int16_t max_tables); + void recv_get_table_names_by_filter(std::vector & _return, const int32_t seqid); + void alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl) override; + int32_t send_alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl); + void recv_alter_table(const int32_t seqid); + void alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context) override; + int32_t send_alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context); + void recv_alter_table_with_environment_context(const int32_t seqid); + void alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade) override; + int32_t send_alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade); + void recv_alter_table_with_cascade(const int32_t seqid); + void alter_table_req(AlterTableResponse& _return, const AlterTableRequest& req) override; + int32_t send_alter_table_req(const AlterTableRequest& req); + void recv_alter_table_req(AlterTableResponse& _return, const int32_t seqid); + void add_partition(Partition& _return, const Partition& new_part) override; + int32_t send_add_partition(const Partition& new_part); + void recv_add_partition(Partition& _return, const int32_t seqid); + void add_partition_with_environment_context(Partition& _return, const Partition& new_part, const EnvironmentContext& environment_context) override; + int32_t send_add_partition_with_environment_context(const Partition& new_part, const EnvironmentContext& environment_context); + void recv_add_partition_with_environment_context(Partition& _return, const int32_t seqid); + int32_t add_partitions(const std::vector & new_parts) override; + int32_t send_add_partitions(const std::vector & new_parts); + int32_t recv_add_partitions(const int32_t seqid); + int32_t add_partitions_pspec(const std::vector & new_parts) override; + int32_t send_add_partitions_pspec(const std::vector & new_parts); + int32_t recv_add_partitions_pspec(const int32_t seqid); + void append_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals) override; + int32_t send_append_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals); + void recv_append_partition(Partition& _return, const int32_t seqid); + void add_partitions_req(AddPartitionsResult& _return, const AddPartitionsRequest& request) override; + int32_t send_add_partitions_req(const AddPartitionsRequest& request); + void recv_add_partitions_req(AddPartitionsResult& _return, const int32_t seqid); + void append_partition_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const EnvironmentContext& environment_context) override; + int32_t send_append_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const EnvironmentContext& environment_context); + void recv_append_partition_with_environment_context(Partition& _return, const int32_t seqid); + void append_partition_req(Partition& _return, const AppendPartitionsRequest& appendPartitionsReq) override; + int32_t send_append_partition_req(const AppendPartitionsRequest& appendPartitionsReq); + void recv_append_partition_req(Partition& _return, const int32_t seqid); + void append_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name) override; + int32_t send_append_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name); + void recv_append_partition_by_name(Partition& _return, const int32_t seqid); + void append_partition_by_name_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context) override; + int32_t send_append_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context); + void recv_append_partition_by_name_with_environment_context(Partition& _return, const int32_t seqid); + bool drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData) override; + int32_t send_drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData); + bool recv_drop_partition(const int32_t seqid); + bool drop_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData, const EnvironmentContext& environment_context) override; + int32_t send_drop_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData, const EnvironmentContext& environment_context); + bool recv_drop_partition_with_environment_context(const int32_t seqid); + bool drop_partition_req(const DropPartitionRequest& dropPartitionReq) override; + int32_t send_drop_partition_req(const DropPartitionRequest& dropPartitionReq); + bool recv_drop_partition_req(const int32_t seqid); + bool drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData) override; + int32_t send_drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData); + bool recv_drop_partition_by_name(const int32_t seqid); + bool drop_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData, const EnvironmentContext& environment_context) override; + int32_t send_drop_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData, const EnvironmentContext& environment_context); + bool recv_drop_partition_by_name_with_environment_context(const int32_t seqid); + void drop_partitions_req(DropPartitionsResult& _return, const DropPartitionsRequest& req) override; + int32_t send_drop_partitions_req(const DropPartitionsRequest& req); + void recv_drop_partitions_req(DropPartitionsResult& _return, const int32_t seqid); + void get_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals) override; + int32_t send_get_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals); + void recv_get_partition(Partition& _return, const int32_t seqid); + void get_partition_req(GetPartitionResponse& _return, const GetPartitionRequest& req) override; + int32_t send_get_partition_req(const GetPartitionRequest& req); + void recv_get_partition_req(GetPartitionResponse& _return, const int32_t seqid); + void exchange_partition(Partition& _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) override; + int32_t send_exchange_partition(const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name); + void recv_exchange_partition(Partition& _return, const int32_t seqid); + void exchange_partitions(std::vector & _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) override; + int32_t send_exchange_partitions(const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name); + void recv_exchange_partitions(std::vector & _return, const int32_t seqid); + void get_partition_with_auth(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const std::string& user_name, const std::vector & group_names) override; + int32_t send_get_partition_with_auth(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const std::string& user_name, const std::vector & group_names); + void recv_get_partition_with_auth(Partition& _return, const int32_t seqid); + void get_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name) override; + int32_t send_get_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name); + void recv_get_partition_by_name(Partition& _return, const int32_t seqid); + void get_partitions(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts) override; + int32_t send_get_partitions(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts); + void recv_get_partitions(std::vector & _return, const int32_t seqid); + void get_partitions_req(PartitionsResponse& _return, const PartitionsRequest& req) override; + int32_t send_get_partitions_req(const PartitionsRequest& req); + void recv_get_partitions_req(PartitionsResponse& _return, const int32_t seqid); + void get_partitions_with_auth(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts, const std::string& user_name, const std::vector & group_names) override; + int32_t send_get_partitions_with_auth(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts, const std::string& user_name, const std::vector & group_names); + void recv_get_partitions_with_auth(std::vector & _return, const int32_t seqid); + void get_partitions_pspec(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int32_t max_parts) override; + int32_t send_get_partitions_pspec(const std::string& db_name, const std::string& tbl_name, const int32_t max_parts); + void recv_get_partitions_pspec(std::vector & _return, const int32_t seqid); + void get_partition_names(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts) override; + int32_t send_get_partition_names(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts); + void recv_get_partition_names(std::vector & _return, const int32_t seqid); + void fetch_partition_names_req(std::vector & _return, const PartitionsRequest& partitionReq) override; + int32_t send_fetch_partition_names_req(const PartitionsRequest& partitionReq); + void recv_fetch_partition_names_req(std::vector & _return, const int32_t seqid); + void get_partition_values(PartitionValuesResponse& _return, const PartitionValuesRequest& request) override; + int32_t send_get_partition_values(const PartitionValuesRequest& request); + void recv_get_partition_values(PartitionValuesResponse& _return, const int32_t seqid); + void get_partitions_ps(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts) override; + int32_t send_get_partitions_ps(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts); + void recv_get_partitions_ps(std::vector & _return, const int32_t seqid); + void get_partitions_ps_with_auth(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts, const std::string& user_name, const std::vector & group_names) override; + int32_t send_get_partitions_ps_with_auth(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts, const std::string& user_name, const std::vector & group_names); + void recv_get_partitions_ps_with_auth(std::vector & _return, const int32_t seqid); + void get_partitions_ps_with_auth_req(GetPartitionsPsWithAuthResponse& _return, const GetPartitionsPsWithAuthRequest& req) override; + int32_t send_get_partitions_ps_with_auth_req(const GetPartitionsPsWithAuthRequest& req); + void recv_get_partitions_ps_with_auth_req(GetPartitionsPsWithAuthResponse& _return, const int32_t seqid); + void get_partition_names_ps(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts) override; + int32_t send_get_partition_names_ps(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts); + void recv_get_partition_names_ps(std::vector & _return, const int32_t seqid); + void get_partition_names_ps_req(GetPartitionNamesPsResponse& _return, const GetPartitionNamesPsRequest& req) override; + int32_t send_get_partition_names_ps_req(const GetPartitionNamesPsRequest& req); + void recv_get_partition_names_ps_req(GetPartitionNamesPsResponse& _return, const int32_t seqid); + void get_partition_names_req(std::vector & _return, const PartitionsByExprRequest& req) override; + int32_t send_get_partition_names_req(const PartitionsByExprRequest& req); + void recv_get_partition_names_req(std::vector & _return, const int32_t seqid); + void get_partitions_by_filter(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int16_t max_parts) override; + int32_t send_get_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int16_t max_parts); + void recv_get_partitions_by_filter(std::vector & _return, const int32_t seqid); + void get_partitions_by_filter_req(std::vector & _return, const GetPartitionsByFilterRequest& req) override; + int32_t send_get_partitions_by_filter_req(const GetPartitionsByFilterRequest& req); + void recv_get_partitions_by_filter_req(std::vector & _return, const int32_t seqid); + void get_part_specs_by_filter(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int32_t max_parts) override; + int32_t send_get_part_specs_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int32_t max_parts); + void recv_get_part_specs_by_filter(std::vector & _return, const int32_t seqid); + void get_partitions_by_expr(PartitionsByExprResult& _return, const PartitionsByExprRequest& req) override; + int32_t send_get_partitions_by_expr(const PartitionsByExprRequest& req); + void recv_get_partitions_by_expr(PartitionsByExprResult& _return, const int32_t seqid); + void get_partitions_spec_by_expr(PartitionsSpecByExprResult& _return, const PartitionsByExprRequest& req) override; + int32_t send_get_partitions_spec_by_expr(const PartitionsByExprRequest& req); + void recv_get_partitions_spec_by_expr(PartitionsSpecByExprResult& _return, const int32_t seqid); + int32_t get_num_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter) override; + int32_t send_get_num_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter); + int32_t recv_get_num_partitions_by_filter(const int32_t seqid); + void get_partitions_by_names(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & names) override; + int32_t send_get_partitions_by_names(const std::string& db_name, const std::string& tbl_name, const std::vector & names); + void recv_get_partitions_by_names(std::vector & _return, const int32_t seqid); + void get_partitions_by_names_req(GetPartitionsByNamesResult& _return, const GetPartitionsByNamesRequest& req) override; + int32_t send_get_partitions_by_names_req(const GetPartitionsByNamesRequest& req); + void recv_get_partitions_by_names_req(GetPartitionsByNamesResult& _return, const int32_t seqid); + void get_properties(PropertyGetResponse& _return, const PropertyGetRequest& req) override; + int32_t send_get_properties(const PropertyGetRequest& req); + void recv_get_properties(PropertyGetResponse& _return, const int32_t seqid); + bool set_properties(const PropertySetRequest& req) override; + int32_t send_set_properties(const PropertySetRequest& req); + bool recv_set_properties(const int32_t seqid); + void alter_partition(const std::string& db_name, const std::string& tbl_name, const Partition& new_part) override; + int32_t send_alter_partition(const std::string& db_name, const std::string& tbl_name, const Partition& new_part); + void recv_alter_partition(const int32_t seqid); + void alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts) override; + int32_t send_alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts); + void recv_alter_partitions(const int32_t seqid); + void alter_partitions_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts, const EnvironmentContext& environment_context) override; + int32_t send_alter_partitions_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts, const EnvironmentContext& environment_context); + void recv_alter_partitions_with_environment_context(const int32_t seqid); + void alter_partitions_req(AlterPartitionsResponse& _return, const AlterPartitionsRequest& req) override; + int32_t send_alter_partitions_req(const AlterPartitionsRequest& req); + void recv_alter_partitions_req(AlterPartitionsResponse& _return, const int32_t seqid); + void alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context) override; + int32_t send_alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context); + void recv_alter_partition_with_environment_context(const int32_t seqid); + void rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const Partition& new_part) override; + int32_t send_rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const Partition& new_part); + void recv_rename_partition(const int32_t seqid); + void rename_partition_req(RenamePartitionResponse& _return, const RenamePartitionRequest& req) override; + int32_t send_rename_partition_req(const RenamePartitionRequest& req); + void recv_rename_partition_req(RenamePartitionResponse& _return, const int32_t seqid); + bool partition_name_has_valid_characters(const std::vector & part_vals, const bool throw_exception) override; + int32_t send_partition_name_has_valid_characters(const std::vector & part_vals, const bool throw_exception); + bool recv_partition_name_has_valid_characters(const int32_t seqid); + void get_config_value(std::string& _return, const std::string& name, const std::string& defaultValue) override; + int32_t send_get_config_value(const std::string& name, const std::string& defaultValue); + void recv_get_config_value(std::string& _return, const int32_t seqid); + void partition_name_to_vals(std::vector & _return, const std::string& part_name) override; + int32_t send_partition_name_to_vals(const std::string& part_name); + void recv_partition_name_to_vals(std::vector & _return, const int32_t seqid); + void partition_name_to_spec(std::map & _return, const std::string& part_name) override; + int32_t send_partition_name_to_spec(const std::string& part_name); + void recv_partition_name_to_spec(std::map & _return, const int32_t seqid); + void markPartitionForEvent(const std::string& db_name, const std::string& tbl_name, const std::map & part_vals, const PartitionEventType::type eventType) override; + int32_t send_markPartitionForEvent(const std::string& db_name, const std::string& tbl_name, const std::map & part_vals, const PartitionEventType::type eventType); + void recv_markPartitionForEvent(const int32_t seqid); + bool isPartitionMarkedForEvent(const std::string& db_name, const std::string& tbl_name, const std::map & part_vals, const PartitionEventType::type eventType) override; + int32_t send_isPartitionMarkedForEvent(const std::string& db_name, const std::string& tbl_name, const std::map & part_vals, const PartitionEventType::type eventType); + bool recv_isPartitionMarkedForEvent(const int32_t seqid); + void get_primary_keys(PrimaryKeysResponse& _return, const PrimaryKeysRequest& request) override; + int32_t send_get_primary_keys(const PrimaryKeysRequest& request); + void recv_get_primary_keys(PrimaryKeysResponse& _return, const int32_t seqid); + void get_foreign_keys(ForeignKeysResponse& _return, const ForeignKeysRequest& request) override; + int32_t send_get_foreign_keys(const ForeignKeysRequest& request); + void recv_get_foreign_keys(ForeignKeysResponse& _return, const int32_t seqid); + void get_unique_constraints(UniqueConstraintsResponse& _return, const UniqueConstraintsRequest& request) override; + int32_t send_get_unique_constraints(const UniqueConstraintsRequest& request); + void recv_get_unique_constraints(UniqueConstraintsResponse& _return, const int32_t seqid); + void get_not_null_constraints(NotNullConstraintsResponse& _return, const NotNullConstraintsRequest& request) override; + int32_t send_get_not_null_constraints(const NotNullConstraintsRequest& request); + void recv_get_not_null_constraints(NotNullConstraintsResponse& _return, const int32_t seqid); + void get_default_constraints(DefaultConstraintsResponse& _return, const DefaultConstraintsRequest& request) override; + int32_t send_get_default_constraints(const DefaultConstraintsRequest& request); + void recv_get_default_constraints(DefaultConstraintsResponse& _return, const int32_t seqid); + void get_check_constraints(CheckConstraintsResponse& _return, const CheckConstraintsRequest& request) override; + int32_t send_get_check_constraints(const CheckConstraintsRequest& request); + void recv_get_check_constraints(CheckConstraintsResponse& _return, const int32_t seqid); + void get_all_table_constraints(AllTableConstraintsResponse& _return, const AllTableConstraintsRequest& request) override; + int32_t send_get_all_table_constraints(const AllTableConstraintsRequest& request); + void recv_get_all_table_constraints(AllTableConstraintsResponse& _return, const int32_t seqid); + bool update_table_column_statistics(const ColumnStatistics& stats_obj) override; + int32_t send_update_table_column_statistics(const ColumnStatistics& stats_obj); + bool recv_update_table_column_statistics(const int32_t seqid); + bool update_partition_column_statistics(const ColumnStatistics& stats_obj) override; + int32_t send_update_partition_column_statistics(const ColumnStatistics& stats_obj); + bool recv_update_partition_column_statistics(const int32_t seqid); + void update_table_column_statistics_req(SetPartitionsStatsResponse& _return, const SetPartitionsStatsRequest& req) override; + int32_t send_update_table_column_statistics_req(const SetPartitionsStatsRequest& req); + void recv_update_table_column_statistics_req(SetPartitionsStatsResponse& _return, const int32_t seqid); + void update_partition_column_statistics_req(SetPartitionsStatsResponse& _return, const SetPartitionsStatsRequest& req) override; + int32_t send_update_partition_column_statistics_req(const SetPartitionsStatsRequest& req); + void recv_update_partition_column_statistics_req(SetPartitionsStatsResponse& _return, const int32_t seqid); + void update_transaction_statistics(const UpdateTransactionalStatsRequest& req) override; + int32_t send_update_transaction_statistics(const UpdateTransactionalStatsRequest& req); + void recv_update_transaction_statistics(const int32_t seqid); + void get_table_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& col_name) override; + int32_t send_get_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name); + void recv_get_table_column_statistics(ColumnStatistics& _return, const int32_t seqid); + void get_partition_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name) override; + int32_t send_get_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name); + void recv_get_partition_column_statistics(ColumnStatistics& _return, const int32_t seqid); + void get_table_statistics_req(TableStatsResult& _return, const TableStatsRequest& request) override; + int32_t send_get_table_statistics_req(const TableStatsRequest& request); + void recv_get_table_statistics_req(TableStatsResult& _return, const int32_t seqid); + void get_partitions_statistics_req(PartitionsStatsResult& _return, const PartitionsStatsRequest& request) override; + int32_t send_get_partitions_statistics_req(const PartitionsStatsRequest& request); + void recv_get_partitions_statistics_req(PartitionsStatsResult& _return, const int32_t seqid); + void get_aggr_stats_for(AggrStats& _return, const PartitionsStatsRequest& request) override; + int32_t send_get_aggr_stats_for(const PartitionsStatsRequest& request); + void recv_get_aggr_stats_for(AggrStats& _return, const int32_t seqid); + bool set_aggr_stats_for(const SetPartitionsStatsRequest& request) override; + int32_t send_set_aggr_stats_for(const SetPartitionsStatsRequest& request); + bool recv_set_aggr_stats_for(const int32_t seqid); + bool delete_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name, const std::string& engine) override; + int32_t send_delete_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name, const std::string& engine); + bool recv_delete_partition_column_statistics(const int32_t seqid); + bool delete_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name, const std::string& engine) override; + int32_t send_delete_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name, const std::string& engine); + bool recv_delete_table_column_statistics(const int32_t seqid); + void create_function(const Function& func) override; + int32_t send_create_function(const Function& func); + void recv_create_function(const int32_t seqid); + void drop_function(const std::string& dbName, const std::string& funcName) override; + int32_t send_drop_function(const std::string& dbName, const std::string& funcName); + void recv_drop_function(const int32_t seqid); + void alter_function(const std::string& dbName, const std::string& funcName, const Function& newFunc) override; + int32_t send_alter_function(const std::string& dbName, const std::string& funcName, const Function& newFunc); + void recv_alter_function(const int32_t seqid); + void get_functions(std::vector & _return, const std::string& dbName, const std::string& pattern) override; + int32_t send_get_functions(const std::string& dbName, const std::string& pattern); + void recv_get_functions(std::vector & _return, const int32_t seqid); + void get_function(Function& _return, const std::string& dbName, const std::string& funcName) override; + int32_t send_get_function(const std::string& dbName, const std::string& funcName); + void recv_get_function(Function& _return, const int32_t seqid); + void get_all_functions(GetAllFunctionsResponse& _return) override; + int32_t send_get_all_functions(); + void recv_get_all_functions(GetAllFunctionsResponse& _return, const int32_t seqid); + bool create_role(const Role& role) override; + int32_t send_create_role(const Role& role); + bool recv_create_role(const int32_t seqid); + bool drop_role(const std::string& role_name) override; + int32_t send_drop_role(const std::string& role_name); + bool recv_drop_role(const int32_t seqid); + void get_role_names(std::vector & _return) override; + int32_t send_get_role_names(); + void recv_get_role_names(std::vector & _return, const int32_t seqid); + bool grant_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type, const std::string& grantor, const PrincipalType::type grantorType, const bool grant_option) override; + int32_t send_grant_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type, const std::string& grantor, const PrincipalType::type grantorType, const bool grant_option); + bool recv_grant_role(const int32_t seqid); + bool revoke_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type) override; + int32_t send_revoke_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type); + bool recv_revoke_role(const int32_t seqid); + void list_roles(std::vector & _return, const std::string& principal_name, const PrincipalType::type principal_type) override; + int32_t send_list_roles(const std::string& principal_name, const PrincipalType::type principal_type); + void recv_list_roles(std::vector & _return, const int32_t seqid); + void grant_revoke_role(GrantRevokeRoleResponse& _return, const GrantRevokeRoleRequest& request) override; + int32_t send_grant_revoke_role(const GrantRevokeRoleRequest& request); + void recv_grant_revoke_role(GrantRevokeRoleResponse& _return, const int32_t seqid); + void get_principals_in_role(GetPrincipalsInRoleResponse& _return, const GetPrincipalsInRoleRequest& request) override; + int32_t send_get_principals_in_role(const GetPrincipalsInRoleRequest& request); + void recv_get_principals_in_role(GetPrincipalsInRoleResponse& _return, const int32_t seqid); + void get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& _return, const GetRoleGrantsForPrincipalRequest& request) override; + int32_t send_get_role_grants_for_principal(const GetRoleGrantsForPrincipalRequest& request); + void recv_get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& _return, const int32_t seqid); + void get_privilege_set(PrincipalPrivilegeSet& _return, const HiveObjectRef& hiveObject, const std::string& user_name, const std::vector & group_names) override; + int32_t send_get_privilege_set(const HiveObjectRef& hiveObject, const std::string& user_name, const std::vector & group_names); + void recv_get_privilege_set(PrincipalPrivilegeSet& _return, const int32_t seqid); + void list_privileges(std::vector & _return, const std::string& principal_name, const PrincipalType::type principal_type, const HiveObjectRef& hiveObject) override; + int32_t send_list_privileges(const std::string& principal_name, const PrincipalType::type principal_type, const HiveObjectRef& hiveObject); + void recv_list_privileges(std::vector & _return, const int32_t seqid); + bool grant_privileges(const PrivilegeBag& privileges) override; + int32_t send_grant_privileges(const PrivilegeBag& privileges); + bool recv_grant_privileges(const int32_t seqid); + bool revoke_privileges(const PrivilegeBag& privileges) override; + int32_t send_revoke_privileges(const PrivilegeBag& privileges); + bool recv_revoke_privileges(const int32_t seqid); + void grant_revoke_privileges(GrantRevokePrivilegeResponse& _return, const GrantRevokePrivilegeRequest& request) override; + int32_t send_grant_revoke_privileges(const GrantRevokePrivilegeRequest& request); + void recv_grant_revoke_privileges(GrantRevokePrivilegeResponse& _return, const int32_t seqid); + void refresh_privileges(GrantRevokePrivilegeResponse& _return, const HiveObjectRef& objToRefresh, const std::string& authorizer, const GrantRevokePrivilegeRequest& grantRequest) override; + int32_t send_refresh_privileges(const HiveObjectRef& objToRefresh, const std::string& authorizer, const GrantRevokePrivilegeRequest& grantRequest); + void recv_refresh_privileges(GrantRevokePrivilegeResponse& _return, const int32_t seqid); + void set_ugi(std::vector & _return, const std::string& user_name, const std::vector & group_names) override; + int32_t send_set_ugi(const std::string& user_name, const std::vector & group_names); + void recv_set_ugi(std::vector & _return, const int32_t seqid); + void get_delegation_token(std::string& _return, const std::string& token_owner, const std::string& renewer_kerberos_principal_name) override; + int32_t send_get_delegation_token(const std::string& token_owner, const std::string& renewer_kerberos_principal_name); + void recv_get_delegation_token(std::string& _return, const int32_t seqid); + int64_t renew_delegation_token(const std::string& token_str_form) override; + int32_t send_renew_delegation_token(const std::string& token_str_form); + int64_t recv_renew_delegation_token(const int32_t seqid); + void cancel_delegation_token(const std::string& token_str_form) override; + int32_t send_cancel_delegation_token(const std::string& token_str_form); + void recv_cancel_delegation_token(const int32_t seqid); + bool add_token(const std::string& token_identifier, const std::string& delegation_token) override; + int32_t send_add_token(const std::string& token_identifier, const std::string& delegation_token); + bool recv_add_token(const int32_t seqid); + bool remove_token(const std::string& token_identifier) override; + int32_t send_remove_token(const std::string& token_identifier); + bool recv_remove_token(const int32_t seqid); + void get_token(std::string& _return, const std::string& token_identifier) override; + int32_t send_get_token(const std::string& token_identifier); + void recv_get_token(std::string& _return, const int32_t seqid); + void get_all_token_identifiers(std::vector & _return) override; + int32_t send_get_all_token_identifiers(); + void recv_get_all_token_identifiers(std::vector & _return, const int32_t seqid); + int32_t add_master_key(const std::string& key) override; + int32_t send_add_master_key(const std::string& key); + int32_t recv_add_master_key(const int32_t seqid); + void update_master_key(const int32_t seq_number, const std::string& key) override; + int32_t send_update_master_key(const int32_t seq_number, const std::string& key); + void recv_update_master_key(const int32_t seqid); + bool remove_master_key(const int32_t key_seq) override; + int32_t send_remove_master_key(const int32_t key_seq); + bool recv_remove_master_key(const int32_t seqid); + void get_master_keys(std::vector & _return) override; + int32_t send_get_master_keys(); + void recv_get_master_keys(std::vector & _return, const int32_t seqid); + void get_open_txns(GetOpenTxnsResponse& _return) override; + int32_t send_get_open_txns(); + void recv_get_open_txns(GetOpenTxnsResponse& _return, const int32_t seqid); + void get_open_txns_info(GetOpenTxnsInfoResponse& _return) override; + int32_t send_get_open_txns_info(); + void recv_get_open_txns_info(GetOpenTxnsInfoResponse& _return, const int32_t seqid); + void open_txns(OpenTxnsResponse& _return, const OpenTxnRequest& rqst) override; + int32_t send_open_txns(const OpenTxnRequest& rqst); + void recv_open_txns(OpenTxnsResponse& _return, const int32_t seqid); + void abort_txn(const AbortTxnRequest& rqst) override; + int32_t send_abort_txn(const AbortTxnRequest& rqst); + void recv_abort_txn(const int32_t seqid); + void abort_txns(const AbortTxnsRequest& rqst) override; + int32_t send_abort_txns(const AbortTxnsRequest& rqst); + void recv_abort_txns(const int32_t seqid); + void commit_txn(const CommitTxnRequest& rqst) override; + int32_t send_commit_txn(const CommitTxnRequest& rqst); + void recv_commit_txn(const int32_t seqid); + int64_t get_latest_txnid_in_conflict(const int64_t txnId) override; + int32_t send_get_latest_txnid_in_conflict(const int64_t txnId); + int64_t recv_get_latest_txnid_in_conflict(const int32_t seqid); + void repl_tbl_writeid_state(const ReplTblWriteIdStateRequest& rqst) override; + int32_t send_repl_tbl_writeid_state(const ReplTblWriteIdStateRequest& rqst); + void recv_repl_tbl_writeid_state(const int32_t seqid); + void get_valid_write_ids(GetValidWriteIdsResponse& _return, const GetValidWriteIdsRequest& rqst) override; + int32_t send_get_valid_write_ids(const GetValidWriteIdsRequest& rqst); + void recv_get_valid_write_ids(GetValidWriteIdsResponse& _return, const int32_t seqid); + void add_write_ids_to_min_history(const int64_t txnId, const std::map & writeIds) override; + int32_t send_add_write_ids_to_min_history(const int64_t txnId, const std::map & writeIds); + void recv_add_write_ids_to_min_history(const int32_t seqid); + void allocate_table_write_ids(AllocateTableWriteIdsResponse& _return, const AllocateTableWriteIdsRequest& rqst) override; + int32_t send_allocate_table_write_ids(const AllocateTableWriteIdsRequest& rqst); + void recv_allocate_table_write_ids(AllocateTableWriteIdsResponse& _return, const int32_t seqid); + void get_max_allocated_table_write_id(MaxAllocatedTableWriteIdResponse& _return, const MaxAllocatedTableWriteIdRequest& rqst) override; + int32_t send_get_max_allocated_table_write_id(const MaxAllocatedTableWriteIdRequest& rqst); + void recv_get_max_allocated_table_write_id(MaxAllocatedTableWriteIdResponse& _return, const int32_t seqid); + void seed_write_id(const SeedTableWriteIdsRequest& rqst) override; + int32_t send_seed_write_id(const SeedTableWriteIdsRequest& rqst); + void recv_seed_write_id(const int32_t seqid); + void seed_txn_id(const SeedTxnIdRequest& rqst) override; + int32_t send_seed_txn_id(const SeedTxnIdRequest& rqst); + void recv_seed_txn_id(const int32_t seqid); + void lock(LockResponse& _return, const LockRequest& rqst) override; + int32_t send_lock(const LockRequest& rqst); + void recv_lock(LockResponse& _return, const int32_t seqid); + void check_lock(LockResponse& _return, const CheckLockRequest& rqst) override; + int32_t send_check_lock(const CheckLockRequest& rqst); + void recv_check_lock(LockResponse& _return, const int32_t seqid); + void unlock(const UnlockRequest& rqst) override; + int32_t send_unlock(const UnlockRequest& rqst); + void recv_unlock(const int32_t seqid); + void show_locks(ShowLocksResponse& _return, const ShowLocksRequest& rqst) override; + int32_t send_show_locks(const ShowLocksRequest& rqst); + void recv_show_locks(ShowLocksResponse& _return, const int32_t seqid); + void heartbeat(const HeartbeatRequest& ids) override; + int32_t send_heartbeat(const HeartbeatRequest& ids); + void recv_heartbeat(const int32_t seqid); + void heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const HeartbeatTxnRangeRequest& txns) override; + int32_t send_heartbeat_txn_range(const HeartbeatTxnRangeRequest& txns); + void recv_heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const int32_t seqid); + void compact(const CompactionRequest& rqst) override; + int32_t send_compact(const CompactionRequest& rqst); + void recv_compact(const int32_t seqid); + void compact2(CompactionResponse& _return, const CompactionRequest& rqst) override; + int32_t send_compact2(const CompactionRequest& rqst); + void recv_compact2(CompactionResponse& _return, const int32_t seqid); + void show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst) override; + int32_t send_show_compact(const ShowCompactRequest& rqst); + void recv_show_compact(ShowCompactResponse& _return, const int32_t seqid); + bool submit_for_cleanup(const CompactionRequest& o1, const int64_t o2, const int64_t o3) override; + int32_t send_submit_for_cleanup(const CompactionRequest& o1, const int64_t o2, const int64_t o3); + bool recv_submit_for_cleanup(const int32_t seqid); + void add_dynamic_partitions(const AddDynamicPartitions& rqst) override; + int32_t send_add_dynamic_partitions(const AddDynamicPartitions& rqst); + void recv_add_dynamic_partitions(const int32_t seqid); + void find_next_compact(OptionalCompactionInfoStruct& _return, const std::string& workerId) override; + int32_t send_find_next_compact(const std::string& workerId); + void recv_find_next_compact(OptionalCompactionInfoStruct& _return, const int32_t seqid); + void find_next_compact2(OptionalCompactionInfoStruct& _return, const FindNextCompactRequest& rqst) override; + int32_t send_find_next_compact2(const FindNextCompactRequest& rqst); + void recv_find_next_compact2(OptionalCompactionInfoStruct& _return, const int32_t seqid); + void update_compactor_state(const CompactionInfoStruct& cr, const int64_t txn_id) override; + int32_t send_update_compactor_state(const CompactionInfoStruct& cr, const int64_t txn_id); + void recv_update_compactor_state(const int32_t seqid); + void find_columns_with_stats(std::vector & _return, const CompactionInfoStruct& cr) override; + int32_t send_find_columns_with_stats(const CompactionInfoStruct& cr); + void recv_find_columns_with_stats(std::vector & _return, const int32_t seqid); + void mark_cleaned(const CompactionInfoStruct& cr) override; + int32_t send_mark_cleaned(const CompactionInfoStruct& cr); + void recv_mark_cleaned(const int32_t seqid); + void mark_compacted(const CompactionInfoStruct& cr) override; + int32_t send_mark_compacted(const CompactionInfoStruct& cr); + void recv_mark_compacted(const int32_t seqid); + void mark_failed(const CompactionInfoStruct& cr) override; + int32_t send_mark_failed(const CompactionInfoStruct& cr); + void recv_mark_failed(const int32_t seqid); + void mark_refused(const CompactionInfoStruct& cr) override; + int32_t send_mark_refused(const CompactionInfoStruct& cr); + void recv_mark_refused(const int32_t seqid); + bool update_compaction_metrics_data(const CompactionMetricsDataStruct& data) override; + int32_t send_update_compaction_metrics_data(const CompactionMetricsDataStruct& data); + bool recv_update_compaction_metrics_data(const int32_t seqid); + void remove_compaction_metrics_data(const CompactionMetricsDataRequest& request) override; + int32_t send_remove_compaction_metrics_data(const CompactionMetricsDataRequest& request); + void recv_remove_compaction_metrics_data(const int32_t seqid); + void set_hadoop_jobid(const std::string& jobId, const int64_t cq_id) override; + int32_t send_set_hadoop_jobid(const std::string& jobId, const int64_t cq_id); + void recv_set_hadoop_jobid(const int32_t seqid); + void get_latest_committed_compaction_info(GetLatestCommittedCompactionInfoResponse& _return, const GetLatestCommittedCompactionInfoRequest& rqst) override; + int32_t send_get_latest_committed_compaction_info(const GetLatestCommittedCompactionInfoRequest& rqst); + void recv_get_latest_committed_compaction_info(GetLatestCommittedCompactionInfoResponse& _return, const int32_t seqid); + void get_next_notification(NotificationEventResponse& _return, const NotificationEventRequest& rqst) override; + int32_t send_get_next_notification(const NotificationEventRequest& rqst); + void recv_get_next_notification(NotificationEventResponse& _return, const int32_t seqid); + void get_current_notificationEventId(CurrentNotificationEventId& _return) override; + int32_t send_get_current_notificationEventId(); + void recv_get_current_notificationEventId(CurrentNotificationEventId& _return, const int32_t seqid); + void get_notification_events_count(NotificationEventsCountResponse& _return, const NotificationEventsCountRequest& rqst) override; + int32_t send_get_notification_events_count(const NotificationEventsCountRequest& rqst); + void recv_get_notification_events_count(NotificationEventsCountResponse& _return, const int32_t seqid); + void fire_listener_event(FireEventResponse& _return, const FireEventRequest& rqst) override; + int32_t send_fire_listener_event(const FireEventRequest& rqst); + void recv_fire_listener_event(FireEventResponse& _return, const int32_t seqid); + void flushCache() override; + int32_t send_flushCache(); + void recv_flushCache(const int32_t seqid); + void add_write_notification_log(WriteNotificationLogResponse& _return, const WriteNotificationLogRequest& rqst) override; + int32_t send_add_write_notification_log(const WriteNotificationLogRequest& rqst); + void recv_add_write_notification_log(WriteNotificationLogResponse& _return, const int32_t seqid); + void add_write_notification_log_in_batch(WriteNotificationLogBatchResponse& _return, const WriteNotificationLogBatchRequest& rqst) override; + int32_t send_add_write_notification_log_in_batch(const WriteNotificationLogBatchRequest& rqst); + void recv_add_write_notification_log_in_batch(WriteNotificationLogBatchResponse& _return, const int32_t seqid); + void cm_recycle(CmRecycleResponse& _return, const CmRecycleRequest& request) override; + int32_t send_cm_recycle(const CmRecycleRequest& request); + void recv_cm_recycle(CmRecycleResponse& _return, const int32_t seqid); + void get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req) override; + int32_t send_get_file_metadata_by_expr(const GetFileMetadataByExprRequest& req); + void recv_get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const int32_t seqid); + void get_file_metadata(GetFileMetadataResult& _return, const GetFileMetadataRequest& req) override; + int32_t send_get_file_metadata(const GetFileMetadataRequest& req); + void recv_get_file_metadata(GetFileMetadataResult& _return, const int32_t seqid); + void put_file_metadata(PutFileMetadataResult& _return, const PutFileMetadataRequest& req) override; + int32_t send_put_file_metadata(const PutFileMetadataRequest& req); + void recv_put_file_metadata(PutFileMetadataResult& _return, const int32_t seqid); + void clear_file_metadata(ClearFileMetadataResult& _return, const ClearFileMetadataRequest& req) override; + int32_t send_clear_file_metadata(const ClearFileMetadataRequest& req); + void recv_clear_file_metadata(ClearFileMetadataResult& _return, const int32_t seqid); + void cache_file_metadata(CacheFileMetadataResult& _return, const CacheFileMetadataRequest& req) override; + int32_t send_cache_file_metadata(const CacheFileMetadataRequest& req); + void recv_cache_file_metadata(CacheFileMetadataResult& _return, const int32_t seqid); + void get_metastore_db_uuid(std::string& _return) override; + int32_t send_get_metastore_db_uuid(); + void recv_get_metastore_db_uuid(std::string& _return, const int32_t seqid); + void create_resource_plan(WMCreateResourcePlanResponse& _return, const WMCreateResourcePlanRequest& request) override; + int32_t send_create_resource_plan(const WMCreateResourcePlanRequest& request); + void recv_create_resource_plan(WMCreateResourcePlanResponse& _return, const int32_t seqid); + void get_resource_plan(WMGetResourcePlanResponse& _return, const WMGetResourcePlanRequest& request) override; + int32_t send_get_resource_plan(const WMGetResourcePlanRequest& request); + void recv_get_resource_plan(WMGetResourcePlanResponse& _return, const int32_t seqid); + void get_active_resource_plan(WMGetActiveResourcePlanResponse& _return, const WMGetActiveResourcePlanRequest& request) override; + int32_t send_get_active_resource_plan(const WMGetActiveResourcePlanRequest& request); + void recv_get_active_resource_plan(WMGetActiveResourcePlanResponse& _return, const int32_t seqid); + void get_all_resource_plans(WMGetAllResourcePlanResponse& _return, const WMGetAllResourcePlanRequest& request) override; + int32_t send_get_all_resource_plans(const WMGetAllResourcePlanRequest& request); + void recv_get_all_resource_plans(WMGetAllResourcePlanResponse& _return, const int32_t seqid); + void alter_resource_plan(WMAlterResourcePlanResponse& _return, const WMAlterResourcePlanRequest& request) override; + int32_t send_alter_resource_plan(const WMAlterResourcePlanRequest& request); + void recv_alter_resource_plan(WMAlterResourcePlanResponse& _return, const int32_t seqid); + void validate_resource_plan(WMValidateResourcePlanResponse& _return, const WMValidateResourcePlanRequest& request) override; + int32_t send_validate_resource_plan(const WMValidateResourcePlanRequest& request); + void recv_validate_resource_plan(WMValidateResourcePlanResponse& _return, const int32_t seqid); + void drop_resource_plan(WMDropResourcePlanResponse& _return, const WMDropResourcePlanRequest& request) override; + int32_t send_drop_resource_plan(const WMDropResourcePlanRequest& request); + void recv_drop_resource_plan(WMDropResourcePlanResponse& _return, const int32_t seqid); + void create_wm_trigger(WMCreateTriggerResponse& _return, const WMCreateTriggerRequest& request) override; + int32_t send_create_wm_trigger(const WMCreateTriggerRequest& request); + void recv_create_wm_trigger(WMCreateTriggerResponse& _return, const int32_t seqid); + void alter_wm_trigger(WMAlterTriggerResponse& _return, const WMAlterTriggerRequest& request) override; + int32_t send_alter_wm_trigger(const WMAlterTriggerRequest& request); + void recv_alter_wm_trigger(WMAlterTriggerResponse& _return, const int32_t seqid); + void drop_wm_trigger(WMDropTriggerResponse& _return, const WMDropTriggerRequest& request) override; + int32_t send_drop_wm_trigger(const WMDropTriggerRequest& request); + void recv_drop_wm_trigger(WMDropTriggerResponse& _return, const int32_t seqid); + void get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const WMGetTriggersForResourePlanRequest& request) override; + int32_t send_get_triggers_for_resourceplan(const WMGetTriggersForResourePlanRequest& request); + void recv_get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const int32_t seqid); + void create_wm_pool(WMCreatePoolResponse& _return, const WMCreatePoolRequest& request) override; + int32_t send_create_wm_pool(const WMCreatePoolRequest& request); + void recv_create_wm_pool(WMCreatePoolResponse& _return, const int32_t seqid); + void alter_wm_pool(WMAlterPoolResponse& _return, const WMAlterPoolRequest& request) override; + int32_t send_alter_wm_pool(const WMAlterPoolRequest& request); + void recv_alter_wm_pool(WMAlterPoolResponse& _return, const int32_t seqid); + void drop_wm_pool(WMDropPoolResponse& _return, const WMDropPoolRequest& request) override; + int32_t send_drop_wm_pool(const WMDropPoolRequest& request); + void recv_drop_wm_pool(WMDropPoolResponse& _return, const int32_t seqid); + void create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const WMCreateOrUpdateMappingRequest& request) override; + int32_t send_create_or_update_wm_mapping(const WMCreateOrUpdateMappingRequest& request); + void recv_create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const int32_t seqid); + void drop_wm_mapping(WMDropMappingResponse& _return, const WMDropMappingRequest& request) override; + int32_t send_drop_wm_mapping(const WMDropMappingRequest& request); + void recv_drop_wm_mapping(WMDropMappingResponse& _return, const int32_t seqid); + void create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return, const WMCreateOrDropTriggerToPoolMappingRequest& request) override; + int32_t send_create_or_drop_wm_trigger_to_pool_mapping(const WMCreateOrDropTriggerToPoolMappingRequest& request); + void recv_create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return, const int32_t seqid); + void create_ischema(const ISchema& schema) override; + int32_t send_create_ischema(const ISchema& schema); + void recv_create_ischema(const int32_t seqid); + void alter_ischema(const AlterISchemaRequest& rqst) override; + int32_t send_alter_ischema(const AlterISchemaRequest& rqst); + void recv_alter_ischema(const int32_t seqid); + void get_ischema(ISchema& _return, const ISchemaName& name) override; + int32_t send_get_ischema(const ISchemaName& name); + void recv_get_ischema(ISchema& _return, const int32_t seqid); + void drop_ischema(const ISchemaName& name) override; + int32_t send_drop_ischema(const ISchemaName& name); + void recv_drop_ischema(const int32_t seqid); + void add_schema_version(const SchemaVersion& schemaVersion) override; + int32_t send_add_schema_version(const SchemaVersion& schemaVersion); + void recv_add_schema_version(const int32_t seqid); + void get_schema_version(SchemaVersion& _return, const SchemaVersionDescriptor& schemaVersion) override; + int32_t send_get_schema_version(const SchemaVersionDescriptor& schemaVersion); + void recv_get_schema_version(SchemaVersion& _return, const int32_t seqid); + void get_schema_latest_version(SchemaVersion& _return, const ISchemaName& schemaName) override; + int32_t send_get_schema_latest_version(const ISchemaName& schemaName); + void recv_get_schema_latest_version(SchemaVersion& _return, const int32_t seqid); + void get_schema_all_versions(std::vector & _return, const ISchemaName& schemaName) override; + int32_t send_get_schema_all_versions(const ISchemaName& schemaName); + void recv_get_schema_all_versions(std::vector & _return, const int32_t seqid); + void drop_schema_version(const SchemaVersionDescriptor& schemaVersion) override; + int32_t send_drop_schema_version(const SchemaVersionDescriptor& schemaVersion); + void recv_drop_schema_version(const int32_t seqid); + void get_schemas_by_cols(FindSchemasByColsResp& _return, const FindSchemasByColsRqst& rqst) override; + int32_t send_get_schemas_by_cols(const FindSchemasByColsRqst& rqst); + void recv_get_schemas_by_cols(FindSchemasByColsResp& _return, const int32_t seqid); + void map_schema_version_to_serde(const MapSchemaVersionToSerdeRequest& rqst) override; + int32_t send_map_schema_version_to_serde(const MapSchemaVersionToSerdeRequest& rqst); + void recv_map_schema_version_to_serde(const int32_t seqid); + void set_schema_version_state(const SetSchemaVersionStateRequest& rqst) override; + int32_t send_set_schema_version_state(const SetSchemaVersionStateRequest& rqst); + void recv_set_schema_version_state(const int32_t seqid); + void add_serde(const SerDeInfo& serde) override; + int32_t send_add_serde(const SerDeInfo& serde); + void recv_add_serde(const int32_t seqid); + void get_serde(SerDeInfo& _return, const GetSerdeRequest& rqst) override; + int32_t send_get_serde(const GetSerdeRequest& rqst); + void recv_get_serde(SerDeInfo& _return, const int32_t seqid); + void get_lock_materialization_rebuild(LockResponse& _return, const std::string& dbName, const std::string& tableName, const int64_t txnId) override; + int32_t send_get_lock_materialization_rebuild(const std::string& dbName, const std::string& tableName, const int64_t txnId); + void recv_get_lock_materialization_rebuild(LockResponse& _return, const int32_t seqid); + bool heartbeat_lock_materialization_rebuild(const std::string& dbName, const std::string& tableName, const int64_t txnId) override; + int32_t send_heartbeat_lock_materialization_rebuild(const std::string& dbName, const std::string& tableName, const int64_t txnId); + bool recv_heartbeat_lock_materialization_rebuild(const int32_t seqid); + void add_runtime_stats(const RuntimeStat& stat) override; + int32_t send_add_runtime_stats(const RuntimeStat& stat); + void recv_add_runtime_stats(const int32_t seqid); + void get_runtime_stats(std::vector & _return, const GetRuntimeStatsRequest& rqst) override; + int32_t send_get_runtime_stats(const GetRuntimeStatsRequest& rqst); + void recv_get_runtime_stats(std::vector & _return, const int32_t seqid); + void get_partitions_with_specs(GetPartitionsResponse& _return, const GetPartitionsRequest& request) override; + int32_t send_get_partitions_with_specs(const GetPartitionsRequest& request); + void recv_get_partitions_with_specs(GetPartitionsResponse& _return, const int32_t seqid); + void scheduled_query_poll(ScheduledQueryPollResponse& _return, const ScheduledQueryPollRequest& request) override; + int32_t send_scheduled_query_poll(const ScheduledQueryPollRequest& request); + void recv_scheduled_query_poll(ScheduledQueryPollResponse& _return, const int32_t seqid); + void scheduled_query_maintenance(const ScheduledQueryMaintenanceRequest& request) override; + int32_t send_scheduled_query_maintenance(const ScheduledQueryMaintenanceRequest& request); + void recv_scheduled_query_maintenance(const int32_t seqid); + void scheduled_query_progress(const ScheduledQueryProgressInfo& info) override; + int32_t send_scheduled_query_progress(const ScheduledQueryProgressInfo& info); + void recv_scheduled_query_progress(const int32_t seqid); + void get_scheduled_query(ScheduledQuery& _return, const ScheduledQueryKey& scheduleKey) override; + int32_t send_get_scheduled_query(const ScheduledQueryKey& scheduleKey); + void recv_get_scheduled_query(ScheduledQuery& _return, const int32_t seqid); + void add_replication_metrics(const ReplicationMetricList& replicationMetricList) override; + int32_t send_add_replication_metrics(const ReplicationMetricList& replicationMetricList); + void recv_add_replication_metrics(const int32_t seqid); + void get_replication_metrics(ReplicationMetricList& _return, const GetReplicationMetricsRequest& rqst) override; + int32_t send_get_replication_metrics(const GetReplicationMetricsRequest& rqst); + void recv_get_replication_metrics(ReplicationMetricList& _return, const int32_t seqid); + void get_open_txns_req(GetOpenTxnsResponse& _return, const GetOpenTxnsRequest& getOpenTxnsRequest) override; + int32_t send_get_open_txns_req(const GetOpenTxnsRequest& getOpenTxnsRequest); + void recv_get_open_txns_req(GetOpenTxnsResponse& _return, const int32_t seqid); + void create_stored_procedure(const StoredProcedure& proc) override; + int32_t send_create_stored_procedure(const StoredProcedure& proc); + void recv_create_stored_procedure(const int32_t seqid); + void get_stored_procedure(StoredProcedure& _return, const StoredProcedureRequest& request) override; + int32_t send_get_stored_procedure(const StoredProcedureRequest& request); + void recv_get_stored_procedure(StoredProcedure& _return, const int32_t seqid); + void drop_stored_procedure(const StoredProcedureRequest& request) override; + int32_t send_drop_stored_procedure(const StoredProcedureRequest& request); + void recv_drop_stored_procedure(const int32_t seqid); + void get_all_stored_procedures(std::vector & _return, const ListStoredProcedureRequest& request) override; + int32_t send_get_all_stored_procedures(const ListStoredProcedureRequest& request); + void recv_get_all_stored_procedures(std::vector & _return, const int32_t seqid); + void find_package(Package& _return, const GetPackageRequest& request) override; + int32_t send_find_package(const GetPackageRequest& request); + void recv_find_package(Package& _return, const int32_t seqid); + void add_package(const AddPackageRequest& request) override; + int32_t send_add_package(const AddPackageRequest& request); + void recv_add_package(const int32_t seqid); + void get_all_packages(std::vector & _return, const ListPackageRequest& request) override; + int32_t send_get_all_packages(const ListPackageRequest& request); + void recv_get_all_packages(std::vector & _return, const int32_t seqid); + void drop_package(const DropPackageRequest& request) override; + int32_t send_drop_package(const DropPackageRequest& request); + void recv_drop_package(const int32_t seqid); + void get_all_write_event_info(std::vector & _return, const GetAllWriteEventInfoRequest& request) override; + int32_t send_get_all_write_event_info(const GetAllWriteEventInfoRequest& request); + void recv_get_all_write_event_info(std::vector & _return, const int32_t seqid); +}; + +#ifdef _MSC_VER + #pragma warning( pop ) +#endif + +}}} // namespace + +#endif diff --git a/src/iceberg/catalog/hive/gen-cpp/fb303_types.cpp b/src/iceberg/catalog/hive/gen-cpp/fb303_types.cpp new file mode 100644 index 000000000..3f1ccdf0d --- /dev/null +++ b/src/iceberg/catalog/hive/gen-cpp/fb303_types.cpp @@ -0,0 +1,53 @@ +/** + * Autogenerated by Thrift Compiler (0.23.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "fb303_types.h" + +#include +#include + +#include + +namespace facebook { namespace fb303 { + +int _kfb_statusValues[] = { + fb_status::DEAD, + fb_status::STARTING, + fb_status::ALIVE, + fb_status::STOPPING, + fb_status::STOPPED, + fb_status::WARNING +}; +const char* _kfb_statusNames[] = { + "DEAD", + "STARTING", + "ALIVE", + "STOPPING", + "STOPPED", + "WARNING" +}; +const std::map _fb_status_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(6, _kfb_statusValues, _kfb_statusNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const fb_status::type& val) { + std::map::const_iterator it = _fb_status_VALUES_TO_NAMES.find(val); + if (it != _fb_status_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const fb_status::type& val) { + std::map::const_iterator it = _fb_status_VALUES_TO_NAMES.find(val); + if (it != _fb_status_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +}} // namespace diff --git a/src/iceberg/catalog/hive/gen-cpp/fb303_types.h b/src/iceberg/catalog/hive/gen-cpp/fb303_types.h new file mode 100644 index 000000000..84df27616 --- /dev/null +++ b/src/iceberg/catalog/hive/gen-cpp/fb303_types.h @@ -0,0 +1,46 @@ +/** + * Autogenerated by Thrift Compiler (0.23.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef fb303_TYPES_H +#define fb303_TYPES_H + +#include + +#include +#include +#include +#include +#include + +#include +#include + + +namespace facebook { namespace fb303 { + +/** + * Common status reporting mechanism across all services + */ +struct fb_status { + enum type { + DEAD = 0, + STARTING = 1, + ALIVE = 2, + STOPPING = 3, + STOPPED = 4, + WARNING = 5 + }; +}; + +extern const std::map _fb_status_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const fb_status::type& val); + +std::string to_string(const fb_status::type& val); + +}} // namespace + +#endif diff --git a/src/iceberg/catalog/hive/gen-cpp/hive_metastore_constants.cpp b/src/iceberg/catalog/hive/gen-cpp/hive_metastore_constants.cpp new file mode 100644 index 000000000..28edb96ea --- /dev/null +++ b/src/iceberg/catalog/hive/gen-cpp/hive_metastore_constants.cpp @@ -0,0 +1,105 @@ +/** + * Autogenerated by Thrift Compiler (0.23.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "hive_metastore_constants.h" + +namespace Apache { namespace Hadoop { namespace Hive { + +const hive_metastoreConstants g_hive_metastore_constants; + +hive_metastoreConstants::hive_metastoreConstants() { + DDL_TIME = "transient_lastDdlTime"; + + ACCESSTYPE_NONE = 1; + + ACCESSTYPE_READONLY = 2; + + ACCESSTYPE_WRITEONLY = 4; + + ACCESSTYPE_READWRITE = 8; + + HIVE_FILTER_FIELD_OWNER = "hive_filter_field_owner__"; + + HIVE_FILTER_FIELD_PARAMS = "hive_filter_field_params__"; + + HIVE_FILTER_FIELD_LAST_ACCESS = "hive_filter_field_last_access__"; + + HIVE_FILTER_FIELD_TABLE_NAME = "hive_filter_field_tableName__"; + + HIVE_FILTER_FIELD_TABLE_TYPE = "hive_filter_field_tableType__"; + + IS_ARCHIVED = "is_archived"; + + ORIGINAL_LOCATION = "original_location"; + + IS_IMMUTABLE = "immutable"; + + META_TABLE_COLUMNS = "columns"; + + META_TABLE_COLUMN_TYPES = "columns.types"; + + BUCKET_FIELD_NAME = "bucket_field_name"; + + BUCKET_COUNT = "bucket_count"; + + FIELD_TO_DIMENSION = "field_to_dimension"; + + IF_PURGE = "ifPurge"; + + META_TABLE_NAME = "name"; + + META_TABLE_DB = "db"; + + META_TABLE_LOCATION = "location"; + + META_TABLE_SERDE = "serde"; + + META_TABLE_PARTITION_COLUMNS = "partition_columns"; + + META_TABLE_PARTITION_COLUMN_TYPES = "partition_columns.types"; + + FILE_INPUT_FORMAT = "file.inputformat"; + + FILE_OUTPUT_FORMAT = "file.outputformat"; + + META_TABLE_STORAGE = "storage_handler"; + + TABLE_IS_TRANSACTIONAL = "transactional"; + + NO_AUTO_COMPACT = "no_auto_compaction"; + + TABLE_TRANSACTIONAL_PROPERTIES = "transactional_properties"; + + TABLE_BUCKETING_VERSION = "bucketing_version"; + + DRUID_CONFIG_PREFIX = "druid."; + + JDBC_CONFIG_PREFIX = "hive.sql."; + + TABLE_IS_CTAS = "created_with_ctas"; + + TABLE_IS_CTLT = "created_with_ctlt"; + + PARTITION_TRANSFORM_SPEC = "partition_transform_spec"; + + NO_CLEANUP = "no_cleanup"; + + CTAS_LEGACY_CONFIG = "create_table_as_external"; + + DEFAULT_TABLE_TYPE = "defaultTableType"; + + TXN_ID = "txnId"; + + WRITE_ID = "writeId"; + + EXPECTED_PARAMETER_KEY = "expected_parameter_key"; + + EXPECTED_PARAMETER_VALUE = "expected_parameter_value"; + +} + +}}} // namespace + diff --git a/src/iceberg/catalog/hive/gen-cpp/hive_metastore_constants.h b/src/iceberg/catalog/hive/gen-cpp/hive_metastore_constants.h new file mode 100644 index 000000000..15acc15f0 --- /dev/null +++ b/src/iceberg/catalog/hive/gen-cpp/hive_metastore_constants.h @@ -0,0 +1,68 @@ +/** + * Autogenerated by Thrift Compiler (0.23.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef hive_metastore_CONSTANTS_H +#define hive_metastore_CONSTANTS_H + +#include "hive_metastore_types.h" + +namespace Apache { namespace Hadoop { namespace Hive { + +class hive_metastoreConstants { + public: + hive_metastoreConstants(); + + std::string DDL_TIME; + int8_t ACCESSTYPE_NONE; + int8_t ACCESSTYPE_READONLY; + int8_t ACCESSTYPE_WRITEONLY; + int8_t ACCESSTYPE_READWRITE; + std::string HIVE_FILTER_FIELD_OWNER; + std::string HIVE_FILTER_FIELD_PARAMS; + std::string HIVE_FILTER_FIELD_LAST_ACCESS; + std::string HIVE_FILTER_FIELD_TABLE_NAME; + std::string HIVE_FILTER_FIELD_TABLE_TYPE; + std::string IS_ARCHIVED; + std::string ORIGINAL_LOCATION; + std::string IS_IMMUTABLE; + std::string META_TABLE_COLUMNS; + std::string META_TABLE_COLUMN_TYPES; + std::string BUCKET_FIELD_NAME; + std::string BUCKET_COUNT; + std::string FIELD_TO_DIMENSION; + std::string IF_PURGE; + std::string META_TABLE_NAME; + std::string META_TABLE_DB; + std::string META_TABLE_LOCATION; + std::string META_TABLE_SERDE; + std::string META_TABLE_PARTITION_COLUMNS; + std::string META_TABLE_PARTITION_COLUMN_TYPES; + std::string FILE_INPUT_FORMAT; + std::string FILE_OUTPUT_FORMAT; + std::string META_TABLE_STORAGE; + std::string TABLE_IS_TRANSACTIONAL; + std::string NO_AUTO_COMPACT; + std::string TABLE_TRANSACTIONAL_PROPERTIES; + std::string TABLE_BUCKETING_VERSION; + std::string DRUID_CONFIG_PREFIX; + std::string JDBC_CONFIG_PREFIX; + std::string TABLE_IS_CTAS; + std::string TABLE_IS_CTLT; + std::string PARTITION_TRANSFORM_SPEC; + std::string NO_CLEANUP; + std::string CTAS_LEGACY_CONFIG; + std::string DEFAULT_TABLE_TYPE; + std::string TXN_ID; + std::string WRITE_ID; + std::string EXPECTED_PARAMETER_KEY; + std::string EXPECTED_PARAMETER_VALUE; +}; + +extern const hive_metastoreConstants g_hive_metastore_constants; + +}}} // namespace + +#endif diff --git a/src/iceberg/catalog/hive/gen-cpp/hive_metastore_types.cpp b/src/iceberg/catalog/hive/gen-cpp/hive_metastore_types.cpp new file mode 100644 index 000000000..362cf060f --- /dev/null +++ b/src/iceberg/catalog/hive/gen-cpp/hive_metastore_types.cpp @@ -0,0 +1,62322 @@ +/** + * Autogenerated by Thrift Compiler (0.23.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "hive_metastore_types.h" + +#include +#include + +#include + +namespace Apache { namespace Hadoop { namespace Hive { + +int _kHiveObjectTypeValues[] = { + HiveObjectType::GLOBAL, + HiveObjectType::DATABASE, + HiveObjectType::TABLE, + HiveObjectType::PARTITION, + HiveObjectType::COLUMN, + HiveObjectType::DATACONNECTOR +}; +const char* _kHiveObjectTypeNames[] = { + "GLOBAL", + "DATABASE", + "TABLE", + "PARTITION", + "COLUMN", + "DATACONNECTOR" +}; +const std::map _HiveObjectType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(6, _kHiveObjectTypeValues, _kHiveObjectTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const HiveObjectType::type& val) { + std::map::const_iterator it = _HiveObjectType_VALUES_TO_NAMES.find(val); + if (it != _HiveObjectType_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const HiveObjectType::type& val) { + std::map::const_iterator it = _HiveObjectType_VALUES_TO_NAMES.find(val); + if (it != _HiveObjectType_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kPrincipalTypeValues[] = { + PrincipalType::USER, + PrincipalType::ROLE, + PrincipalType::GROUP +}; +const char* _kPrincipalTypeNames[] = { + "USER", + "ROLE", + "GROUP" +}; +const std::map _PrincipalType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kPrincipalTypeValues, _kPrincipalTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const PrincipalType::type& val) { + std::map::const_iterator it = _PrincipalType_VALUES_TO_NAMES.find(val); + if (it != _PrincipalType_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const PrincipalType::type& val) { + std::map::const_iterator it = _PrincipalType_VALUES_TO_NAMES.find(val); + if (it != _PrincipalType_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kPartitionEventTypeValues[] = { + PartitionEventType::LOAD_DONE +}; +const char* _kPartitionEventTypeNames[] = { + "LOAD_DONE" +}; +const std::map _PartitionEventType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(1, _kPartitionEventTypeValues, _kPartitionEventTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const PartitionEventType::type& val) { + std::map::const_iterator it = _PartitionEventType_VALUES_TO_NAMES.find(val); + if (it != _PartitionEventType_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const PartitionEventType::type& val) { + std::map::const_iterator it = _PartitionEventType_VALUES_TO_NAMES.find(val); + if (it != _PartitionEventType_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kTxnStateValues[] = { + TxnState::COMMITTED, + TxnState::ABORTED, + TxnState::OPEN +}; +const char* _kTxnStateNames[] = { + "COMMITTED", + "ABORTED", + "OPEN" +}; +const std::map _TxnState_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kTxnStateValues, _kTxnStateNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const TxnState::type& val) { + std::map::const_iterator it = _TxnState_VALUES_TO_NAMES.find(val); + if (it != _TxnState_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const TxnState::type& val) { + std::map::const_iterator it = _TxnState_VALUES_TO_NAMES.find(val); + if (it != _TxnState_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kLockLevelValues[] = { + LockLevel::DB, + LockLevel::TABLE, + LockLevel::PARTITION +}; +const char* _kLockLevelNames[] = { + "DB", + "TABLE", + "PARTITION" +}; +const std::map _LockLevel_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kLockLevelValues, _kLockLevelNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const LockLevel::type& val) { + std::map::const_iterator it = _LockLevel_VALUES_TO_NAMES.find(val); + if (it != _LockLevel_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const LockLevel::type& val) { + std::map::const_iterator it = _LockLevel_VALUES_TO_NAMES.find(val); + if (it != _LockLevel_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kLockStateValues[] = { + LockState::ACQUIRED, + LockState::WAITING, + LockState::ABORT, + LockState::NOT_ACQUIRED +}; +const char* _kLockStateNames[] = { + "ACQUIRED", + "WAITING", + "ABORT", + "NOT_ACQUIRED" +}; +const std::map _LockState_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(4, _kLockStateValues, _kLockStateNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const LockState::type& val) { + std::map::const_iterator it = _LockState_VALUES_TO_NAMES.find(val); + if (it != _LockState_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const LockState::type& val) { + std::map::const_iterator it = _LockState_VALUES_TO_NAMES.find(val); + if (it != _LockState_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kLockTypeValues[] = { + LockType::SHARED_READ, + LockType::SHARED_WRITE, + LockType::EXCLUSIVE, + LockType::EXCL_WRITE +}; +const char* _kLockTypeNames[] = { + "SHARED_READ", + "SHARED_WRITE", + "EXCLUSIVE", + "EXCL_WRITE" +}; +const std::map _LockType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(4, _kLockTypeValues, _kLockTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const LockType::type& val) { + std::map::const_iterator it = _LockType_VALUES_TO_NAMES.find(val); + if (it != _LockType_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const LockType::type& val) { + std::map::const_iterator it = _LockType_VALUES_TO_NAMES.find(val); + if (it != _LockType_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kCompactionTypeValues[] = { + CompactionType::MINOR, + CompactionType::MAJOR, + CompactionType::REBALANCE, + CompactionType::ABORT_TXN_CLEANUP +}; +const char* _kCompactionTypeNames[] = { + "MINOR", + "MAJOR", + "REBALANCE", + "ABORT_TXN_CLEANUP" +}; +const std::map _CompactionType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(4, _kCompactionTypeValues, _kCompactionTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const CompactionType::type& val) { + std::map::const_iterator it = _CompactionType_VALUES_TO_NAMES.find(val); + if (it != _CompactionType_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const CompactionType::type& val) { + std::map::const_iterator it = _CompactionType_VALUES_TO_NAMES.find(val); + if (it != _CompactionType_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kGrantRevokeTypeValues[] = { + GrantRevokeType::GRANT, + GrantRevokeType::REVOKE +}; +const char* _kGrantRevokeTypeNames[] = { + "GRANT", + "REVOKE" +}; +const std::map _GrantRevokeType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kGrantRevokeTypeValues, _kGrantRevokeTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const GrantRevokeType::type& val) { + std::map::const_iterator it = _GrantRevokeType_VALUES_TO_NAMES.find(val); + if (it != _GrantRevokeType_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const GrantRevokeType::type& val) { + std::map::const_iterator it = _GrantRevokeType_VALUES_TO_NAMES.find(val); + if (it != _GrantRevokeType_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kDataOperationTypeValues[] = { + DataOperationType::SELECT, + DataOperationType::INSERT, + DataOperationType::UPDATE, + DataOperationType::DELETE, + DataOperationType::UNSET, + DataOperationType::NO_TXN +}; +const char* _kDataOperationTypeNames[] = { + "SELECT", + "INSERT", + "UPDATE", + "DELETE", + "UNSET", + "NO_TXN" +}; +const std::map _DataOperationType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(6, _kDataOperationTypeValues, _kDataOperationTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const DataOperationType::type& val) { + std::map::const_iterator it = _DataOperationType_VALUES_TO_NAMES.find(val); + if (it != _DataOperationType_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const DataOperationType::type& val) { + std::map::const_iterator it = _DataOperationType_VALUES_TO_NAMES.find(val); + if (it != _DataOperationType_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kEventRequestTypeValues[] = { + EventRequestType::INSERT, + EventRequestType::UPDATE, + EventRequestType::DELETE +}; +const char* _kEventRequestTypeNames[] = { + "INSERT", + "UPDATE", + "DELETE" +}; +const std::map _EventRequestType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kEventRequestTypeValues, _kEventRequestTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const EventRequestType::type& val) { + std::map::const_iterator it = _EventRequestType_VALUES_TO_NAMES.find(val); + if (it != _EventRequestType_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const EventRequestType::type& val) { + std::map::const_iterator it = _EventRequestType_VALUES_TO_NAMES.find(val); + if (it != _EventRequestType_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kSerdeTypeValues[] = { + SerdeType::HIVE, + SerdeType::SCHEMA_REGISTRY +}; +const char* _kSerdeTypeNames[] = { + "HIVE", + "SCHEMA_REGISTRY" +}; +const std::map _SerdeType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kSerdeTypeValues, _kSerdeTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const SerdeType::type& val) { + std::map::const_iterator it = _SerdeType_VALUES_TO_NAMES.find(val); + if (it != _SerdeType_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const SerdeType::type& val) { + std::map::const_iterator it = _SerdeType_VALUES_TO_NAMES.find(val); + if (it != _SerdeType_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kSchemaTypeValues[] = { + SchemaType::HIVE, + SchemaType::AVRO +}; +const char* _kSchemaTypeNames[] = { + "HIVE", + "AVRO" +}; +const std::map _SchemaType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kSchemaTypeValues, _kSchemaTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const SchemaType::type& val) { + std::map::const_iterator it = _SchemaType_VALUES_TO_NAMES.find(val); + if (it != _SchemaType_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const SchemaType::type& val) { + std::map::const_iterator it = _SchemaType_VALUES_TO_NAMES.find(val); + if (it != _SchemaType_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kSchemaCompatibilityValues[] = { + SchemaCompatibility::NONE, + SchemaCompatibility::BACKWARD, + SchemaCompatibility::FORWARD, + SchemaCompatibility::BOTH +}; +const char* _kSchemaCompatibilityNames[] = { + "NONE", + "BACKWARD", + "FORWARD", + "BOTH" +}; +const std::map _SchemaCompatibility_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(4, _kSchemaCompatibilityValues, _kSchemaCompatibilityNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const SchemaCompatibility::type& val) { + std::map::const_iterator it = _SchemaCompatibility_VALUES_TO_NAMES.find(val); + if (it != _SchemaCompatibility_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const SchemaCompatibility::type& val) { + std::map::const_iterator it = _SchemaCompatibility_VALUES_TO_NAMES.find(val); + if (it != _SchemaCompatibility_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kSchemaValidationValues[] = { + SchemaValidation::LATEST, + SchemaValidation::ALL +}; +const char* _kSchemaValidationNames[] = { + "LATEST", + "ALL" +}; +const std::map _SchemaValidation_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kSchemaValidationValues, _kSchemaValidationNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const SchemaValidation::type& val) { + std::map::const_iterator it = _SchemaValidation_VALUES_TO_NAMES.find(val); + if (it != _SchemaValidation_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const SchemaValidation::type& val) { + std::map::const_iterator it = _SchemaValidation_VALUES_TO_NAMES.find(val); + if (it != _SchemaValidation_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kSchemaVersionStateValues[] = { + SchemaVersionState::INITIATED, + SchemaVersionState::START_REVIEW, + SchemaVersionState::CHANGES_REQUIRED, + SchemaVersionState::REVIEWED, + SchemaVersionState::ENABLED, + SchemaVersionState::DISABLED, + SchemaVersionState::ARCHIVED, + SchemaVersionState::DELETED +}; +const char* _kSchemaVersionStateNames[] = { + "INITIATED", + "START_REVIEW", + "CHANGES_REQUIRED", + "REVIEWED", + "ENABLED", + "DISABLED", + "ARCHIVED", + "DELETED" +}; +const std::map _SchemaVersionState_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(8, _kSchemaVersionStateValues, _kSchemaVersionStateNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const SchemaVersionState::type& val) { + std::map::const_iterator it = _SchemaVersionState_VALUES_TO_NAMES.find(val); + if (it != _SchemaVersionState_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const SchemaVersionState::type& val) { + std::map::const_iterator it = _SchemaVersionState_VALUES_TO_NAMES.find(val); + if (it != _SchemaVersionState_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kDatabaseTypeValues[] = { + DatabaseType::NATIVE, + DatabaseType::REMOTE +}; +const char* _kDatabaseTypeNames[] = { + "NATIVE", + "REMOTE" +}; +const std::map _DatabaseType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kDatabaseTypeValues, _kDatabaseTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const DatabaseType::type& val) { + std::map::const_iterator it = _DatabaseType_VALUES_TO_NAMES.find(val); + if (it != _DatabaseType_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const DatabaseType::type& val) { + std::map::const_iterator it = _DatabaseType_VALUES_TO_NAMES.find(val); + if (it != _DatabaseType_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kFunctionTypeValues[] = { + FunctionType::JAVA +}; +const char* _kFunctionTypeNames[] = { + "JAVA" +}; +const std::map _FunctionType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(1, _kFunctionTypeValues, _kFunctionTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const FunctionType::type& val) { + std::map::const_iterator it = _FunctionType_VALUES_TO_NAMES.find(val); + if (it != _FunctionType_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const FunctionType::type& val) { + std::map::const_iterator it = _FunctionType_VALUES_TO_NAMES.find(val); + if (it != _FunctionType_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kResourceTypeValues[] = { + ResourceType::JAR, + ResourceType::FILE, + ResourceType::ARCHIVE +}; +const char* _kResourceTypeNames[] = { + "JAR", + "FILE", + "ARCHIVE" +}; +const std::map _ResourceType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kResourceTypeValues, _kResourceTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const ResourceType::type& val) { + std::map::const_iterator it = _ResourceType_VALUES_TO_NAMES.find(val); + if (it != _ResourceType_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const ResourceType::type& val) { + std::map::const_iterator it = _ResourceType_VALUES_TO_NAMES.find(val); + if (it != _ResourceType_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kTxnTypeValues[] = { + TxnType::DEFAULT, + TxnType::REPL_CREATED, + TxnType::READ_ONLY, + TxnType::COMPACTION, + TxnType::MATER_VIEW_REBUILD, + TxnType::SOFT_DELETE, + TxnType::REBALANCE_COMPACTION +}; +const char* _kTxnTypeNames[] = { + "DEFAULT", + "REPL_CREATED", + "READ_ONLY", + "COMPACTION", + "MATER_VIEW_REBUILD", + "SOFT_DELETE", + "REBALANCE_COMPACTION" +}; +const std::map _TxnType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(7, _kTxnTypeValues, _kTxnTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const TxnType::type& val) { + std::map::const_iterator it = _TxnType_VALUES_TO_NAMES.find(val); + if (it != _TxnType_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const TxnType::type& val) { + std::map::const_iterator it = _TxnType_VALUES_TO_NAMES.find(val); + if (it != _TxnType_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kGetTablesExtRequestFieldsValues[] = { + GetTablesExtRequestFields::ACCESS_TYPE, + GetTablesExtRequestFields::PROCESSOR_CAPABILITIES, + GetTablesExtRequestFields::ALL +}; +const char* _kGetTablesExtRequestFieldsNames[] = { + "ACCESS_TYPE", + "PROCESSOR_CAPABILITIES", + "ALL" +}; +const std::map _GetTablesExtRequestFields_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kGetTablesExtRequestFieldsValues, _kGetTablesExtRequestFieldsNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const GetTablesExtRequestFields::type& val) { + std::map::const_iterator it = _GetTablesExtRequestFields_VALUES_TO_NAMES.find(val); + if (it != _GetTablesExtRequestFields_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const GetTablesExtRequestFields::type& val) { + std::map::const_iterator it = _GetTablesExtRequestFields_VALUES_TO_NAMES.find(val); + if (it != _GetTablesExtRequestFields_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kCompactionMetricsMetricTypeValues[] = { + CompactionMetricsMetricType::NUM_OBSOLETE_DELTAS, + CompactionMetricsMetricType::NUM_DELTAS, + CompactionMetricsMetricType::NUM_SMALL_DELTAS +}; +const char* _kCompactionMetricsMetricTypeNames[] = { + "NUM_OBSOLETE_DELTAS", + "NUM_DELTAS", + "NUM_SMALL_DELTAS" +}; +const std::map _CompactionMetricsMetricType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kCompactionMetricsMetricTypeValues, _kCompactionMetricsMetricTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const CompactionMetricsMetricType::type& val) { + std::map::const_iterator it = _CompactionMetricsMetricType_VALUES_TO_NAMES.find(val); + if (it != _CompactionMetricsMetricType_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const CompactionMetricsMetricType::type& val) { + std::map::const_iterator it = _CompactionMetricsMetricType_VALUES_TO_NAMES.find(val); + if (it != _CompactionMetricsMetricType_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kFileMetadataExprTypeValues[] = { + FileMetadataExprType::ORC_SARG +}; +const char* _kFileMetadataExprTypeNames[] = { + "ORC_SARG" +}; +const std::map _FileMetadataExprType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(1, _kFileMetadataExprTypeValues, _kFileMetadataExprTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const FileMetadataExprType::type& val) { + std::map::const_iterator it = _FileMetadataExprType_VALUES_TO_NAMES.find(val); + if (it != _FileMetadataExprType_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const FileMetadataExprType::type& val) { + std::map::const_iterator it = _FileMetadataExprType_VALUES_TO_NAMES.find(val); + if (it != _FileMetadataExprType_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kClientCapabilityValues[] = { + ClientCapability::TEST_CAPABILITY, + ClientCapability::INSERT_ONLY_TABLES +}; +const char* _kClientCapabilityNames[] = { + "TEST_CAPABILITY", + "INSERT_ONLY_TABLES" +}; +const std::map _ClientCapability_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kClientCapabilityValues, _kClientCapabilityNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const ClientCapability::type& val) { + std::map::const_iterator it = _ClientCapability_VALUES_TO_NAMES.find(val); + if (it != _ClientCapability_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const ClientCapability::type& val) { + std::map::const_iterator it = _ClientCapability_VALUES_TO_NAMES.find(val); + if (it != _ClientCapability_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kWMResourcePlanStatusValues[] = { + WMResourcePlanStatus::ACTIVE, + WMResourcePlanStatus::ENABLED, + WMResourcePlanStatus::DISABLED +}; +const char* _kWMResourcePlanStatusNames[] = { + "ACTIVE", + "ENABLED", + "DISABLED" +}; +const std::map _WMResourcePlanStatus_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kWMResourcePlanStatusValues, _kWMResourcePlanStatusNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const WMResourcePlanStatus::type& val) { + std::map::const_iterator it = _WMResourcePlanStatus_VALUES_TO_NAMES.find(val); + if (it != _WMResourcePlanStatus_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const WMResourcePlanStatus::type& val) { + std::map::const_iterator it = _WMResourcePlanStatus_VALUES_TO_NAMES.find(val); + if (it != _WMResourcePlanStatus_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kWMPoolSchedulingPolicyValues[] = { + WMPoolSchedulingPolicy::FAIR, + WMPoolSchedulingPolicy::FIFO +}; +const char* _kWMPoolSchedulingPolicyNames[] = { + "FAIR", + "FIFO" +}; +const std::map _WMPoolSchedulingPolicy_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kWMPoolSchedulingPolicyValues, _kWMPoolSchedulingPolicyNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const WMPoolSchedulingPolicy::type& val) { + std::map::const_iterator it = _WMPoolSchedulingPolicy_VALUES_TO_NAMES.find(val); + if (it != _WMPoolSchedulingPolicy_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const WMPoolSchedulingPolicy::type& val) { + std::map::const_iterator it = _WMPoolSchedulingPolicy_VALUES_TO_NAMES.find(val); + if (it != _WMPoolSchedulingPolicy_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kScheduledQueryMaintenanceRequestTypeValues[] = { + ScheduledQueryMaintenanceRequestType::CREATE, + ScheduledQueryMaintenanceRequestType::ALTER, + ScheduledQueryMaintenanceRequestType::DROP +}; +const char* _kScheduledQueryMaintenanceRequestTypeNames[] = { + "CREATE", + "ALTER", + "DROP" +}; +const std::map _ScheduledQueryMaintenanceRequestType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kScheduledQueryMaintenanceRequestTypeValues, _kScheduledQueryMaintenanceRequestTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const ScheduledQueryMaintenanceRequestType::type& val) { + std::map::const_iterator it = _ScheduledQueryMaintenanceRequestType_VALUES_TO_NAMES.find(val); + if (it != _ScheduledQueryMaintenanceRequestType_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const ScheduledQueryMaintenanceRequestType::type& val) { + std::map::const_iterator it = _ScheduledQueryMaintenanceRequestType_VALUES_TO_NAMES.find(val); + if (it != _ScheduledQueryMaintenanceRequestType_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kQueryStateValues[] = { + QueryState::INITED, + QueryState::EXECUTING, + QueryState::FAILED, + QueryState::FINISHED, + QueryState::TIMED_OUT, + QueryState::AUTO_DISABLED +}; +const char* _kQueryStateNames[] = { + "INITED", + "EXECUTING", + "FAILED", + "FINISHED", + "TIMED_OUT", + "AUTO_DISABLED" +}; +const std::map _QueryState_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(6, _kQueryStateValues, _kQueryStateNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const QueryState::type& val) { + std::map::const_iterator it = _QueryState_VALUES_TO_NAMES.find(val); + if (it != _QueryState_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const QueryState::type& val) { + std::map::const_iterator it = _QueryState_VALUES_TO_NAMES.find(val); + if (it != _QueryState_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + +int _kPartitionFilterModeValues[] = { + PartitionFilterMode::BY_NAMES, + PartitionFilterMode::BY_VALUES, + PartitionFilterMode::BY_EXPR +}; +const char* _kPartitionFilterModeNames[] = { + "BY_NAMES", + "BY_VALUES", + "BY_EXPR" +}; +const std::map _PartitionFilterMode_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kPartitionFilterModeValues, _kPartitionFilterModeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr)); + +std::ostream& operator<<(std::ostream& out, const PartitionFilterMode::type& val) { + std::map::const_iterator it = _PartitionFilterMode_VALUES_TO_NAMES.find(val); + if (it != _PartitionFilterMode_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast(val); + } + return out; +} + +std::string to_string(const PartitionFilterMode::type& val) { + std::map::const_iterator it = _PartitionFilterMode_VALUES_TO_NAMES.find(val); + if (it != _PartitionFilterMode_VALUES_TO_NAMES.end()) { + return std::string(it->second); + } else { + return std::to_string(static_cast(val)); + } +} + + +Version::~Version() noexcept { +} + +Version::Version() noexcept + : version(), + comments() { +} + +void Version::__set_version(const std::string& val) { + this->version = val; +} + +void Version::__set_comments(const std::string& val) { + this->comments = val; +} +std::ostream& operator<<(std::ostream& out, const Version& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Version::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->version); + this->__isset.version = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->comments); + this->__isset.comments = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Version::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Version"); + + xfer += oprot->writeFieldBegin("version", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->version); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("comments", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->comments); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Version &a, Version &b) noexcept { + using ::std::swap; + swap(a.version, b.version); + swap(a.comments, b.comments); + swap(a.__isset, b.__isset); +} + +bool Version::operator==(const Version & rhs) const +{ + if (!(version == rhs.version)) + return false; + if (!(comments == rhs.comments)) + return false; + return true; +} + +Version::Version(const Version& other0) { + version = other0.version; + comments = other0.comments; + __isset = other0.__isset; +} +Version& Version::operator=(const Version& other1) { + version = other1.version; + comments = other1.comments; + __isset = other1.__isset; + return *this; +} +void Version::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Version("; + out << "version=" << to_string(version); + out << ", " << "comments=" << to_string(comments); + out << ")"; +} + + +FieldSchema::~FieldSchema() noexcept { +} + +FieldSchema::FieldSchema() noexcept + : name(), + type(), + comment() { +} + +void FieldSchema::__set_name(const std::string& val) { + this->name = val; +} + +void FieldSchema::__set_type(const std::string& val) { + this->type = val; +} + +void FieldSchema::__set_comment(const std::string& val) { + this->comment = val; +} +std::ostream& operator<<(std::ostream& out, const FieldSchema& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t FieldSchema::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->type); + this->__isset.type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->comment); + this->__isset.comment = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FieldSchema::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FieldSchema"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->type); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("comment", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->comment); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(FieldSchema &a, FieldSchema &b) noexcept { + using ::std::swap; + swap(a.name, b.name); + swap(a.type, b.type); + swap(a.comment, b.comment); + swap(a.__isset, b.__isset); +} + +bool FieldSchema::operator==(const FieldSchema & rhs) const +{ + if (!(name == rhs.name)) + return false; + if (!(type == rhs.type)) + return false; + if (!(comment == rhs.comment)) + return false; + return true; +} + +FieldSchema::FieldSchema(const FieldSchema& other2) { + name = other2.name; + type = other2.type; + comment = other2.comment; + __isset = other2.__isset; +} +FieldSchema& FieldSchema::operator=(const FieldSchema& other3) { + name = other3.name; + type = other3.type; + comment = other3.comment; + __isset = other3.__isset; + return *this; +} +void FieldSchema::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "FieldSchema("; + out << "name=" << to_string(name); + out << ", " << "type=" << to_string(type); + out << ", " << "comment=" << to_string(comment); + out << ")"; +} + + +EnvironmentContext::~EnvironmentContext() noexcept { +} + +EnvironmentContext::EnvironmentContext() noexcept { +} + +void EnvironmentContext::__set_properties(const std::map & val) { + this->properties = val; +} +std::ostream& operator<<(std::ostream& out, const EnvironmentContext& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t EnvironmentContext::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->properties.clear(); + uint32_t _size4; + ::apache::thrift::protocol::TType _ktype5; + ::apache::thrift::protocol::TType _vtype6; + xfer += iprot->readMapBegin(_ktype5, _vtype6, _size4); + uint32_t _i8; + for (_i8 = 0; _i8 < _size4; ++_i8) + { + std::string _key9; + xfer += iprot->readString(_key9); + std::string& _val10 = this->properties[_key9]; + xfer += iprot->readString(_val10); + } + xfer += iprot->readMapEnd(); + } + this->__isset.properties = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t EnvironmentContext::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("EnvironmentContext"); + + xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 1); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->properties.size())); + std::map ::const_iterator _iter11; + for (_iter11 = this->properties.begin(); _iter11 != this->properties.end(); ++_iter11) + { + xfer += oprot->writeString(_iter11->first); + xfer += oprot->writeString(_iter11->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(EnvironmentContext &a, EnvironmentContext &b) noexcept { + using ::std::swap; + swap(a.properties, b.properties); + swap(a.__isset, b.__isset); +} + +bool EnvironmentContext::operator==(const EnvironmentContext & rhs) const +{ + if (!(properties == rhs.properties)) + return false; + return true; +} + +EnvironmentContext::EnvironmentContext(const EnvironmentContext& other12) { + properties = other12.properties; + __isset = other12.__isset; +} +EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other13) { + properties = other13.properties; + __isset = other13.__isset; + return *this; +} +void EnvironmentContext::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "EnvironmentContext("; + out << "properties=" << to_string(properties); + out << ")"; +} + + +SQLPrimaryKey::~SQLPrimaryKey() noexcept { +} + +SQLPrimaryKey::SQLPrimaryKey() noexcept + : table_db(), + table_name(), + column_name(), + key_seq(0), + pk_name(), + enable_cstr(0), + validate_cstr(0), + rely_cstr(0), + catName() { +} + +void SQLPrimaryKey::__set_table_db(const std::string& val) { + this->table_db = val; +} + +void SQLPrimaryKey::__set_table_name(const std::string& val) { + this->table_name = val; +} + +void SQLPrimaryKey::__set_column_name(const std::string& val) { + this->column_name = val; +} + +void SQLPrimaryKey::__set_key_seq(const int32_t val) { + this->key_seq = val; +} + +void SQLPrimaryKey::__set_pk_name(const std::string& val) { + this->pk_name = val; +} + +void SQLPrimaryKey::__set_enable_cstr(const bool val) { + this->enable_cstr = val; +} + +void SQLPrimaryKey::__set_validate_cstr(const bool val) { + this->validate_cstr = val; +} + +void SQLPrimaryKey::__set_rely_cstr(const bool val) { + this->rely_cstr = val; +} + +void SQLPrimaryKey::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} +std::ostream& operator<<(std::ostream& out, const SQLPrimaryKey& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t SQLPrimaryKey::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->table_db); + this->__isset.table_db = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->table_name); + this->__isset.table_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->column_name); + this->__isset.column_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->key_seq); + this->__isset.key_seq = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->pk_name); + this->__isset.pk_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->enable_cstr); + this->__isset.enable_cstr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->validate_cstr); + this->__isset.validate_cstr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->rely_cstr); + this->__isset.rely_cstr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t SQLPrimaryKey::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("SQLPrimaryKey"); + + xfer += oprot->writeFieldBegin("table_db", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->table_db); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->table_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("column_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->column_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("key_seq", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32(this->key_seq); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("pk_name", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->pk_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("enable_cstr", ::apache::thrift::protocol::T_BOOL, 6); + xfer += oprot->writeBool(this->enable_cstr); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("validate_cstr", ::apache::thrift::protocol::T_BOOL, 7); + xfer += oprot->writeBool(this->validate_cstr); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("rely_cstr", ::apache::thrift::protocol::T_BOOL, 8); + xfer += oprot->writeBool(this->rely_cstr); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 9); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(SQLPrimaryKey &a, SQLPrimaryKey &b) noexcept { + using ::std::swap; + swap(a.table_db, b.table_db); + swap(a.table_name, b.table_name); + swap(a.column_name, b.column_name); + swap(a.key_seq, b.key_seq); + swap(a.pk_name, b.pk_name); + swap(a.enable_cstr, b.enable_cstr); + swap(a.validate_cstr, b.validate_cstr); + swap(a.rely_cstr, b.rely_cstr); + swap(a.catName, b.catName); + swap(a.__isset, b.__isset); +} + +bool SQLPrimaryKey::operator==(const SQLPrimaryKey & rhs) const +{ + if (!(table_db == rhs.table_db)) + return false; + if (!(table_name == rhs.table_name)) + return false; + if (!(column_name == rhs.column_name)) + return false; + if (!(key_seq == rhs.key_seq)) + return false; + if (!(pk_name == rhs.pk_name)) + return false; + if (!(enable_cstr == rhs.enable_cstr)) + return false; + if (!(validate_cstr == rhs.validate_cstr)) + return false; + if (!(rely_cstr == rhs.rely_cstr)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + return true; +} + +SQLPrimaryKey::SQLPrimaryKey(const SQLPrimaryKey& other14) { + table_db = other14.table_db; + table_name = other14.table_name; + column_name = other14.column_name; + key_seq = other14.key_seq; + pk_name = other14.pk_name; + enable_cstr = other14.enable_cstr; + validate_cstr = other14.validate_cstr; + rely_cstr = other14.rely_cstr; + catName = other14.catName; + __isset = other14.__isset; +} +SQLPrimaryKey& SQLPrimaryKey::operator=(const SQLPrimaryKey& other15) { + table_db = other15.table_db; + table_name = other15.table_name; + column_name = other15.column_name; + key_seq = other15.key_seq; + pk_name = other15.pk_name; + enable_cstr = other15.enable_cstr; + validate_cstr = other15.validate_cstr; + rely_cstr = other15.rely_cstr; + catName = other15.catName; + __isset = other15.__isset; + return *this; +} +void SQLPrimaryKey::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "SQLPrimaryKey("; + out << "table_db=" << to_string(table_db); + out << ", " << "table_name=" << to_string(table_name); + out << ", " << "column_name=" << to_string(column_name); + out << ", " << "key_seq=" << to_string(key_seq); + out << ", " << "pk_name=" << to_string(pk_name); + out << ", " << "enable_cstr=" << to_string(enable_cstr); + out << ", " << "validate_cstr=" << to_string(validate_cstr); + out << ", " << "rely_cstr=" << to_string(rely_cstr); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ")"; +} + + +SQLForeignKey::~SQLForeignKey() noexcept { +} + +SQLForeignKey::SQLForeignKey() noexcept + : pktable_db(), + pktable_name(), + pkcolumn_name(), + fktable_db(), + fktable_name(), + fkcolumn_name(), + key_seq(0), + update_rule(0), + delete_rule(0), + fk_name(), + pk_name(), + enable_cstr(0), + validate_cstr(0), + rely_cstr(0), + catName() { +} + +void SQLForeignKey::__set_pktable_db(const std::string& val) { + this->pktable_db = val; +} + +void SQLForeignKey::__set_pktable_name(const std::string& val) { + this->pktable_name = val; +} + +void SQLForeignKey::__set_pkcolumn_name(const std::string& val) { + this->pkcolumn_name = val; +} + +void SQLForeignKey::__set_fktable_db(const std::string& val) { + this->fktable_db = val; +} + +void SQLForeignKey::__set_fktable_name(const std::string& val) { + this->fktable_name = val; +} + +void SQLForeignKey::__set_fkcolumn_name(const std::string& val) { + this->fkcolumn_name = val; +} + +void SQLForeignKey::__set_key_seq(const int32_t val) { + this->key_seq = val; +} + +void SQLForeignKey::__set_update_rule(const int32_t val) { + this->update_rule = val; +} + +void SQLForeignKey::__set_delete_rule(const int32_t val) { + this->delete_rule = val; +} + +void SQLForeignKey::__set_fk_name(const std::string& val) { + this->fk_name = val; +} + +void SQLForeignKey::__set_pk_name(const std::string& val) { + this->pk_name = val; +} + +void SQLForeignKey::__set_enable_cstr(const bool val) { + this->enable_cstr = val; +} + +void SQLForeignKey::__set_validate_cstr(const bool val) { + this->validate_cstr = val; +} + +void SQLForeignKey::__set_rely_cstr(const bool val) { + this->rely_cstr = val; +} + +void SQLForeignKey::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} +std::ostream& operator<<(std::ostream& out, const SQLForeignKey& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t SQLForeignKey::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->pktable_db); + this->__isset.pktable_db = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->pktable_name); + this->__isset.pktable_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->pkcolumn_name); + this->__isset.pkcolumn_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->fktable_db); + this->__isset.fktable_db = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->fktable_name); + this->__isset.fktable_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->fkcolumn_name); + this->__isset.fkcolumn_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->key_seq); + this->__isset.key_seq = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->update_rule); + this->__isset.update_rule = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->delete_rule); + this->__isset.delete_rule = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->fk_name); + this->__isset.fk_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 11: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->pk_name); + this->__isset.pk_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 12: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->enable_cstr); + this->__isset.enable_cstr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 13: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->validate_cstr); + this->__isset.validate_cstr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 14: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->rely_cstr); + this->__isset.rely_cstr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 15: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t SQLForeignKey::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("SQLForeignKey"); + + xfer += oprot->writeFieldBegin("pktable_db", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->pktable_db); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("pktable_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->pktable_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("pkcolumn_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->pkcolumn_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("fktable_db", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->fktable_db); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("fktable_name", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->fktable_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("fkcolumn_name", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->fkcolumn_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("key_seq", ::apache::thrift::protocol::T_I32, 7); + xfer += oprot->writeI32(this->key_seq); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("update_rule", ::apache::thrift::protocol::T_I32, 8); + xfer += oprot->writeI32(this->update_rule); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("delete_rule", ::apache::thrift::protocol::T_I32, 9); + xfer += oprot->writeI32(this->delete_rule); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("fk_name", ::apache::thrift::protocol::T_STRING, 10); + xfer += oprot->writeString(this->fk_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("pk_name", ::apache::thrift::protocol::T_STRING, 11); + xfer += oprot->writeString(this->pk_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("enable_cstr", ::apache::thrift::protocol::T_BOOL, 12); + xfer += oprot->writeBool(this->enable_cstr); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("validate_cstr", ::apache::thrift::protocol::T_BOOL, 13); + xfer += oprot->writeBool(this->validate_cstr); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("rely_cstr", ::apache::thrift::protocol::T_BOOL, 14); + xfer += oprot->writeBool(this->rely_cstr); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 15); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(SQLForeignKey &a, SQLForeignKey &b) noexcept { + using ::std::swap; + swap(a.pktable_db, b.pktable_db); + swap(a.pktable_name, b.pktable_name); + swap(a.pkcolumn_name, b.pkcolumn_name); + swap(a.fktable_db, b.fktable_db); + swap(a.fktable_name, b.fktable_name); + swap(a.fkcolumn_name, b.fkcolumn_name); + swap(a.key_seq, b.key_seq); + swap(a.update_rule, b.update_rule); + swap(a.delete_rule, b.delete_rule); + swap(a.fk_name, b.fk_name); + swap(a.pk_name, b.pk_name); + swap(a.enable_cstr, b.enable_cstr); + swap(a.validate_cstr, b.validate_cstr); + swap(a.rely_cstr, b.rely_cstr); + swap(a.catName, b.catName); + swap(a.__isset, b.__isset); +} + +bool SQLForeignKey::operator==(const SQLForeignKey & rhs) const +{ + if (!(pktable_db == rhs.pktable_db)) + return false; + if (!(pktable_name == rhs.pktable_name)) + return false; + if (!(pkcolumn_name == rhs.pkcolumn_name)) + return false; + if (!(fktable_db == rhs.fktable_db)) + return false; + if (!(fktable_name == rhs.fktable_name)) + return false; + if (!(fkcolumn_name == rhs.fkcolumn_name)) + return false; + if (!(key_seq == rhs.key_seq)) + return false; + if (!(update_rule == rhs.update_rule)) + return false; + if (!(delete_rule == rhs.delete_rule)) + return false; + if (!(fk_name == rhs.fk_name)) + return false; + if (!(pk_name == rhs.pk_name)) + return false; + if (!(enable_cstr == rhs.enable_cstr)) + return false; + if (!(validate_cstr == rhs.validate_cstr)) + return false; + if (!(rely_cstr == rhs.rely_cstr)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + return true; +} + +SQLForeignKey::SQLForeignKey(const SQLForeignKey& other16) { + pktable_db = other16.pktable_db; + pktable_name = other16.pktable_name; + pkcolumn_name = other16.pkcolumn_name; + fktable_db = other16.fktable_db; + fktable_name = other16.fktable_name; + fkcolumn_name = other16.fkcolumn_name; + key_seq = other16.key_seq; + update_rule = other16.update_rule; + delete_rule = other16.delete_rule; + fk_name = other16.fk_name; + pk_name = other16.pk_name; + enable_cstr = other16.enable_cstr; + validate_cstr = other16.validate_cstr; + rely_cstr = other16.rely_cstr; + catName = other16.catName; + __isset = other16.__isset; +} +SQLForeignKey& SQLForeignKey::operator=(const SQLForeignKey& other17) { + pktable_db = other17.pktable_db; + pktable_name = other17.pktable_name; + pkcolumn_name = other17.pkcolumn_name; + fktable_db = other17.fktable_db; + fktable_name = other17.fktable_name; + fkcolumn_name = other17.fkcolumn_name; + key_seq = other17.key_seq; + update_rule = other17.update_rule; + delete_rule = other17.delete_rule; + fk_name = other17.fk_name; + pk_name = other17.pk_name; + enable_cstr = other17.enable_cstr; + validate_cstr = other17.validate_cstr; + rely_cstr = other17.rely_cstr; + catName = other17.catName; + __isset = other17.__isset; + return *this; +} +void SQLForeignKey::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "SQLForeignKey("; + out << "pktable_db=" << to_string(pktable_db); + out << ", " << "pktable_name=" << to_string(pktable_name); + out << ", " << "pkcolumn_name=" << to_string(pkcolumn_name); + out << ", " << "fktable_db=" << to_string(fktable_db); + out << ", " << "fktable_name=" << to_string(fktable_name); + out << ", " << "fkcolumn_name=" << to_string(fkcolumn_name); + out << ", " << "key_seq=" << to_string(key_seq); + out << ", " << "update_rule=" << to_string(update_rule); + out << ", " << "delete_rule=" << to_string(delete_rule); + out << ", " << "fk_name=" << to_string(fk_name); + out << ", " << "pk_name=" << to_string(pk_name); + out << ", " << "enable_cstr=" << to_string(enable_cstr); + out << ", " << "validate_cstr=" << to_string(validate_cstr); + out << ", " << "rely_cstr=" << to_string(rely_cstr); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ")"; +} + + +SQLUniqueConstraint::~SQLUniqueConstraint() noexcept { +} + +SQLUniqueConstraint::SQLUniqueConstraint() noexcept + : catName(), + table_db(), + table_name(), + column_name(), + key_seq(0), + uk_name(), + enable_cstr(0), + validate_cstr(0), + rely_cstr(0) { +} + +void SQLUniqueConstraint::__set_catName(const std::string& val) { + this->catName = val; +} + +void SQLUniqueConstraint::__set_table_db(const std::string& val) { + this->table_db = val; +} + +void SQLUniqueConstraint::__set_table_name(const std::string& val) { + this->table_name = val; +} + +void SQLUniqueConstraint::__set_column_name(const std::string& val) { + this->column_name = val; +} + +void SQLUniqueConstraint::__set_key_seq(const int32_t val) { + this->key_seq = val; +} + +void SQLUniqueConstraint::__set_uk_name(const std::string& val) { + this->uk_name = val; +} + +void SQLUniqueConstraint::__set_enable_cstr(const bool val) { + this->enable_cstr = val; +} + +void SQLUniqueConstraint::__set_validate_cstr(const bool val) { + this->validate_cstr = val; +} + +void SQLUniqueConstraint::__set_rely_cstr(const bool val) { + this->rely_cstr = val; +} +std::ostream& operator<<(std::ostream& out, const SQLUniqueConstraint& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t SQLUniqueConstraint::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->table_db); + this->__isset.table_db = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->table_name); + this->__isset.table_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->column_name); + this->__isset.column_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->key_seq); + this->__isset.key_seq = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->uk_name); + this->__isset.uk_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->enable_cstr); + this->__isset.enable_cstr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->validate_cstr); + this->__isset.validate_cstr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->rely_cstr); + this->__isset.rely_cstr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t SQLUniqueConstraint::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("SQLUniqueConstraint"); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table_db", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->table_db); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->table_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("column_name", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->column_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("key_seq", ::apache::thrift::protocol::T_I32, 5); + xfer += oprot->writeI32(this->key_seq); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("uk_name", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->uk_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("enable_cstr", ::apache::thrift::protocol::T_BOOL, 7); + xfer += oprot->writeBool(this->enable_cstr); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("validate_cstr", ::apache::thrift::protocol::T_BOOL, 8); + xfer += oprot->writeBool(this->validate_cstr); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("rely_cstr", ::apache::thrift::protocol::T_BOOL, 9); + xfer += oprot->writeBool(this->rely_cstr); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(SQLUniqueConstraint &a, SQLUniqueConstraint &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.table_db, b.table_db); + swap(a.table_name, b.table_name); + swap(a.column_name, b.column_name); + swap(a.key_seq, b.key_seq); + swap(a.uk_name, b.uk_name); + swap(a.enable_cstr, b.enable_cstr); + swap(a.validate_cstr, b.validate_cstr); + swap(a.rely_cstr, b.rely_cstr); + swap(a.__isset, b.__isset); +} + +bool SQLUniqueConstraint::operator==(const SQLUniqueConstraint & rhs) const +{ + if (!(catName == rhs.catName)) + return false; + if (!(table_db == rhs.table_db)) + return false; + if (!(table_name == rhs.table_name)) + return false; + if (!(column_name == rhs.column_name)) + return false; + if (!(key_seq == rhs.key_seq)) + return false; + if (!(uk_name == rhs.uk_name)) + return false; + if (!(enable_cstr == rhs.enable_cstr)) + return false; + if (!(validate_cstr == rhs.validate_cstr)) + return false; + if (!(rely_cstr == rhs.rely_cstr)) + return false; + return true; +} + +SQLUniqueConstraint::SQLUniqueConstraint(const SQLUniqueConstraint& other18) { + catName = other18.catName; + table_db = other18.table_db; + table_name = other18.table_name; + column_name = other18.column_name; + key_seq = other18.key_seq; + uk_name = other18.uk_name; + enable_cstr = other18.enable_cstr; + validate_cstr = other18.validate_cstr; + rely_cstr = other18.rely_cstr; + __isset = other18.__isset; +} +SQLUniqueConstraint& SQLUniqueConstraint::operator=(const SQLUniqueConstraint& other19) { + catName = other19.catName; + table_db = other19.table_db; + table_name = other19.table_name; + column_name = other19.column_name; + key_seq = other19.key_seq; + uk_name = other19.uk_name; + enable_cstr = other19.enable_cstr; + validate_cstr = other19.validate_cstr; + rely_cstr = other19.rely_cstr; + __isset = other19.__isset; + return *this; +} +void SQLUniqueConstraint::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "SQLUniqueConstraint("; + out << "catName=" << to_string(catName); + out << ", " << "table_db=" << to_string(table_db); + out << ", " << "table_name=" << to_string(table_name); + out << ", " << "column_name=" << to_string(column_name); + out << ", " << "key_seq=" << to_string(key_seq); + out << ", " << "uk_name=" << to_string(uk_name); + out << ", " << "enable_cstr=" << to_string(enable_cstr); + out << ", " << "validate_cstr=" << to_string(validate_cstr); + out << ", " << "rely_cstr=" << to_string(rely_cstr); + out << ")"; +} + + +SQLNotNullConstraint::~SQLNotNullConstraint() noexcept { +} + +SQLNotNullConstraint::SQLNotNullConstraint() noexcept + : catName(), + table_db(), + table_name(), + column_name(), + nn_name(), + enable_cstr(0), + validate_cstr(0), + rely_cstr(0) { +} + +void SQLNotNullConstraint::__set_catName(const std::string& val) { + this->catName = val; +} + +void SQLNotNullConstraint::__set_table_db(const std::string& val) { + this->table_db = val; +} + +void SQLNotNullConstraint::__set_table_name(const std::string& val) { + this->table_name = val; +} + +void SQLNotNullConstraint::__set_column_name(const std::string& val) { + this->column_name = val; +} + +void SQLNotNullConstraint::__set_nn_name(const std::string& val) { + this->nn_name = val; +} + +void SQLNotNullConstraint::__set_enable_cstr(const bool val) { + this->enable_cstr = val; +} + +void SQLNotNullConstraint::__set_validate_cstr(const bool val) { + this->validate_cstr = val; +} + +void SQLNotNullConstraint::__set_rely_cstr(const bool val) { + this->rely_cstr = val; +} +std::ostream& operator<<(std::ostream& out, const SQLNotNullConstraint& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t SQLNotNullConstraint::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->table_db); + this->__isset.table_db = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->table_name); + this->__isset.table_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->column_name); + this->__isset.column_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->nn_name); + this->__isset.nn_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->enable_cstr); + this->__isset.enable_cstr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->validate_cstr); + this->__isset.validate_cstr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->rely_cstr); + this->__isset.rely_cstr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t SQLNotNullConstraint::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("SQLNotNullConstraint"); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table_db", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->table_db); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->table_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("column_name", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->column_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("nn_name", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->nn_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("enable_cstr", ::apache::thrift::protocol::T_BOOL, 6); + xfer += oprot->writeBool(this->enable_cstr); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("validate_cstr", ::apache::thrift::protocol::T_BOOL, 7); + xfer += oprot->writeBool(this->validate_cstr); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("rely_cstr", ::apache::thrift::protocol::T_BOOL, 8); + xfer += oprot->writeBool(this->rely_cstr); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(SQLNotNullConstraint &a, SQLNotNullConstraint &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.table_db, b.table_db); + swap(a.table_name, b.table_name); + swap(a.column_name, b.column_name); + swap(a.nn_name, b.nn_name); + swap(a.enable_cstr, b.enable_cstr); + swap(a.validate_cstr, b.validate_cstr); + swap(a.rely_cstr, b.rely_cstr); + swap(a.__isset, b.__isset); +} + +bool SQLNotNullConstraint::operator==(const SQLNotNullConstraint & rhs) const +{ + if (!(catName == rhs.catName)) + return false; + if (!(table_db == rhs.table_db)) + return false; + if (!(table_name == rhs.table_name)) + return false; + if (!(column_name == rhs.column_name)) + return false; + if (!(nn_name == rhs.nn_name)) + return false; + if (!(enable_cstr == rhs.enable_cstr)) + return false; + if (!(validate_cstr == rhs.validate_cstr)) + return false; + if (!(rely_cstr == rhs.rely_cstr)) + return false; + return true; +} + +SQLNotNullConstraint::SQLNotNullConstraint(const SQLNotNullConstraint& other20) { + catName = other20.catName; + table_db = other20.table_db; + table_name = other20.table_name; + column_name = other20.column_name; + nn_name = other20.nn_name; + enable_cstr = other20.enable_cstr; + validate_cstr = other20.validate_cstr; + rely_cstr = other20.rely_cstr; + __isset = other20.__isset; +} +SQLNotNullConstraint& SQLNotNullConstraint::operator=(const SQLNotNullConstraint& other21) { + catName = other21.catName; + table_db = other21.table_db; + table_name = other21.table_name; + column_name = other21.column_name; + nn_name = other21.nn_name; + enable_cstr = other21.enable_cstr; + validate_cstr = other21.validate_cstr; + rely_cstr = other21.rely_cstr; + __isset = other21.__isset; + return *this; +} +void SQLNotNullConstraint::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "SQLNotNullConstraint("; + out << "catName=" << to_string(catName); + out << ", " << "table_db=" << to_string(table_db); + out << ", " << "table_name=" << to_string(table_name); + out << ", " << "column_name=" << to_string(column_name); + out << ", " << "nn_name=" << to_string(nn_name); + out << ", " << "enable_cstr=" << to_string(enable_cstr); + out << ", " << "validate_cstr=" << to_string(validate_cstr); + out << ", " << "rely_cstr=" << to_string(rely_cstr); + out << ")"; +} + + +SQLDefaultConstraint::~SQLDefaultConstraint() noexcept { +} + +SQLDefaultConstraint::SQLDefaultConstraint() noexcept + : catName(), + table_db(), + table_name(), + column_name(), + default_value(), + dc_name(), + enable_cstr(0), + validate_cstr(0), + rely_cstr(0) { +} + +void SQLDefaultConstraint::__set_catName(const std::string& val) { + this->catName = val; +} + +void SQLDefaultConstraint::__set_table_db(const std::string& val) { + this->table_db = val; +} + +void SQLDefaultConstraint::__set_table_name(const std::string& val) { + this->table_name = val; +} + +void SQLDefaultConstraint::__set_column_name(const std::string& val) { + this->column_name = val; +} + +void SQLDefaultConstraint::__set_default_value(const std::string& val) { + this->default_value = val; +} + +void SQLDefaultConstraint::__set_dc_name(const std::string& val) { + this->dc_name = val; +} + +void SQLDefaultConstraint::__set_enable_cstr(const bool val) { + this->enable_cstr = val; +} + +void SQLDefaultConstraint::__set_validate_cstr(const bool val) { + this->validate_cstr = val; +} + +void SQLDefaultConstraint::__set_rely_cstr(const bool val) { + this->rely_cstr = val; +} +std::ostream& operator<<(std::ostream& out, const SQLDefaultConstraint& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t SQLDefaultConstraint::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->table_db); + this->__isset.table_db = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->table_name); + this->__isset.table_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->column_name); + this->__isset.column_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->default_value); + this->__isset.default_value = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dc_name); + this->__isset.dc_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->enable_cstr); + this->__isset.enable_cstr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->validate_cstr); + this->__isset.validate_cstr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->rely_cstr); + this->__isset.rely_cstr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t SQLDefaultConstraint::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("SQLDefaultConstraint"); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table_db", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->table_db); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->table_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("column_name", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->column_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("default_value", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->default_value); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dc_name", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->dc_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("enable_cstr", ::apache::thrift::protocol::T_BOOL, 7); + xfer += oprot->writeBool(this->enable_cstr); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("validate_cstr", ::apache::thrift::protocol::T_BOOL, 8); + xfer += oprot->writeBool(this->validate_cstr); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("rely_cstr", ::apache::thrift::protocol::T_BOOL, 9); + xfer += oprot->writeBool(this->rely_cstr); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(SQLDefaultConstraint &a, SQLDefaultConstraint &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.table_db, b.table_db); + swap(a.table_name, b.table_name); + swap(a.column_name, b.column_name); + swap(a.default_value, b.default_value); + swap(a.dc_name, b.dc_name); + swap(a.enable_cstr, b.enable_cstr); + swap(a.validate_cstr, b.validate_cstr); + swap(a.rely_cstr, b.rely_cstr); + swap(a.__isset, b.__isset); +} + +bool SQLDefaultConstraint::operator==(const SQLDefaultConstraint & rhs) const +{ + if (!(catName == rhs.catName)) + return false; + if (!(table_db == rhs.table_db)) + return false; + if (!(table_name == rhs.table_name)) + return false; + if (!(column_name == rhs.column_name)) + return false; + if (!(default_value == rhs.default_value)) + return false; + if (!(dc_name == rhs.dc_name)) + return false; + if (!(enable_cstr == rhs.enable_cstr)) + return false; + if (!(validate_cstr == rhs.validate_cstr)) + return false; + if (!(rely_cstr == rhs.rely_cstr)) + return false; + return true; +} + +SQLDefaultConstraint::SQLDefaultConstraint(const SQLDefaultConstraint& other22) { + catName = other22.catName; + table_db = other22.table_db; + table_name = other22.table_name; + column_name = other22.column_name; + default_value = other22.default_value; + dc_name = other22.dc_name; + enable_cstr = other22.enable_cstr; + validate_cstr = other22.validate_cstr; + rely_cstr = other22.rely_cstr; + __isset = other22.__isset; +} +SQLDefaultConstraint& SQLDefaultConstraint::operator=(const SQLDefaultConstraint& other23) { + catName = other23.catName; + table_db = other23.table_db; + table_name = other23.table_name; + column_name = other23.column_name; + default_value = other23.default_value; + dc_name = other23.dc_name; + enable_cstr = other23.enable_cstr; + validate_cstr = other23.validate_cstr; + rely_cstr = other23.rely_cstr; + __isset = other23.__isset; + return *this; +} +void SQLDefaultConstraint::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "SQLDefaultConstraint("; + out << "catName=" << to_string(catName); + out << ", " << "table_db=" << to_string(table_db); + out << ", " << "table_name=" << to_string(table_name); + out << ", " << "column_name=" << to_string(column_name); + out << ", " << "default_value=" << to_string(default_value); + out << ", " << "dc_name=" << to_string(dc_name); + out << ", " << "enable_cstr=" << to_string(enable_cstr); + out << ", " << "validate_cstr=" << to_string(validate_cstr); + out << ", " << "rely_cstr=" << to_string(rely_cstr); + out << ")"; +} + + +SQLCheckConstraint::~SQLCheckConstraint() noexcept { +} + +SQLCheckConstraint::SQLCheckConstraint() noexcept + : catName(), + table_db(), + table_name(), + column_name(), + check_expression(), + dc_name(), + enable_cstr(0), + validate_cstr(0), + rely_cstr(0) { +} + +void SQLCheckConstraint::__set_catName(const std::string& val) { + this->catName = val; +} + +void SQLCheckConstraint::__set_table_db(const std::string& val) { + this->table_db = val; +} + +void SQLCheckConstraint::__set_table_name(const std::string& val) { + this->table_name = val; +} + +void SQLCheckConstraint::__set_column_name(const std::string& val) { + this->column_name = val; +} + +void SQLCheckConstraint::__set_check_expression(const std::string& val) { + this->check_expression = val; +} + +void SQLCheckConstraint::__set_dc_name(const std::string& val) { + this->dc_name = val; +} + +void SQLCheckConstraint::__set_enable_cstr(const bool val) { + this->enable_cstr = val; +} + +void SQLCheckConstraint::__set_validate_cstr(const bool val) { + this->validate_cstr = val; +} + +void SQLCheckConstraint::__set_rely_cstr(const bool val) { + this->rely_cstr = val; +} +std::ostream& operator<<(std::ostream& out, const SQLCheckConstraint& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t SQLCheckConstraint::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->table_db); + this->__isset.table_db = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->table_name); + this->__isset.table_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->column_name); + this->__isset.column_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->check_expression); + this->__isset.check_expression = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dc_name); + this->__isset.dc_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->enable_cstr); + this->__isset.enable_cstr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->validate_cstr); + this->__isset.validate_cstr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->rely_cstr); + this->__isset.rely_cstr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t SQLCheckConstraint::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("SQLCheckConstraint"); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table_db", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->table_db); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->table_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("column_name", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->column_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("check_expression", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->check_expression); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dc_name", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->dc_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("enable_cstr", ::apache::thrift::protocol::T_BOOL, 7); + xfer += oprot->writeBool(this->enable_cstr); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("validate_cstr", ::apache::thrift::protocol::T_BOOL, 8); + xfer += oprot->writeBool(this->validate_cstr); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("rely_cstr", ::apache::thrift::protocol::T_BOOL, 9); + xfer += oprot->writeBool(this->rely_cstr); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(SQLCheckConstraint &a, SQLCheckConstraint &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.table_db, b.table_db); + swap(a.table_name, b.table_name); + swap(a.column_name, b.column_name); + swap(a.check_expression, b.check_expression); + swap(a.dc_name, b.dc_name); + swap(a.enable_cstr, b.enable_cstr); + swap(a.validate_cstr, b.validate_cstr); + swap(a.rely_cstr, b.rely_cstr); + swap(a.__isset, b.__isset); +} + +bool SQLCheckConstraint::operator==(const SQLCheckConstraint & rhs) const +{ + if (!(catName == rhs.catName)) + return false; + if (!(table_db == rhs.table_db)) + return false; + if (!(table_name == rhs.table_name)) + return false; + if (!(column_name == rhs.column_name)) + return false; + if (!(check_expression == rhs.check_expression)) + return false; + if (!(dc_name == rhs.dc_name)) + return false; + if (!(enable_cstr == rhs.enable_cstr)) + return false; + if (!(validate_cstr == rhs.validate_cstr)) + return false; + if (!(rely_cstr == rhs.rely_cstr)) + return false; + return true; +} + +SQLCheckConstraint::SQLCheckConstraint(const SQLCheckConstraint& other24) { + catName = other24.catName; + table_db = other24.table_db; + table_name = other24.table_name; + column_name = other24.column_name; + check_expression = other24.check_expression; + dc_name = other24.dc_name; + enable_cstr = other24.enable_cstr; + validate_cstr = other24.validate_cstr; + rely_cstr = other24.rely_cstr; + __isset = other24.__isset; +} +SQLCheckConstraint& SQLCheckConstraint::operator=(const SQLCheckConstraint& other25) { + catName = other25.catName; + table_db = other25.table_db; + table_name = other25.table_name; + column_name = other25.column_name; + check_expression = other25.check_expression; + dc_name = other25.dc_name; + enable_cstr = other25.enable_cstr; + validate_cstr = other25.validate_cstr; + rely_cstr = other25.rely_cstr; + __isset = other25.__isset; + return *this; +} +void SQLCheckConstraint::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "SQLCheckConstraint("; + out << "catName=" << to_string(catName); + out << ", " << "table_db=" << to_string(table_db); + out << ", " << "table_name=" << to_string(table_name); + out << ", " << "column_name=" << to_string(column_name); + out << ", " << "check_expression=" << to_string(check_expression); + out << ", " << "dc_name=" << to_string(dc_name); + out << ", " << "enable_cstr=" << to_string(enable_cstr); + out << ", " << "validate_cstr=" << to_string(validate_cstr); + out << ", " << "rely_cstr=" << to_string(rely_cstr); + out << ")"; +} + + +SQLAllTableConstraints::~SQLAllTableConstraints() noexcept { +} + +SQLAllTableConstraints::SQLAllTableConstraints() noexcept { +} + +void SQLAllTableConstraints::__set_primaryKeys(const std::vector & val) { + this->primaryKeys = val; +__isset.primaryKeys = true; +} + +void SQLAllTableConstraints::__set_foreignKeys(const std::vector & val) { + this->foreignKeys = val; +__isset.foreignKeys = true; +} + +void SQLAllTableConstraints::__set_uniqueConstraints(const std::vector & val) { + this->uniqueConstraints = val; +__isset.uniqueConstraints = true; +} + +void SQLAllTableConstraints::__set_notNullConstraints(const std::vector & val) { + this->notNullConstraints = val; +__isset.notNullConstraints = true; +} + +void SQLAllTableConstraints::__set_defaultConstraints(const std::vector & val) { + this->defaultConstraints = val; +__isset.defaultConstraints = true; +} + +void SQLAllTableConstraints::__set_checkConstraints(const std::vector & val) { + this->checkConstraints = val; +__isset.checkConstraints = true; +} +std::ostream& operator<<(std::ostream& out, const SQLAllTableConstraints& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t SQLAllTableConstraints::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->primaryKeys.clear(); + uint32_t _size26; + ::apache::thrift::protocol::TType _etype29; + xfer += iprot->readListBegin(_etype29, _size26); + this->primaryKeys.resize(_size26); + uint32_t _i30; + for (_i30 = 0; _i30 < _size26; ++_i30) + { + xfer += this->primaryKeys[_i30].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.primaryKeys = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->foreignKeys.clear(); + uint32_t _size31; + ::apache::thrift::protocol::TType _etype34; + xfer += iprot->readListBegin(_etype34, _size31); + this->foreignKeys.resize(_size31); + uint32_t _i35; + for (_i35 = 0; _i35 < _size31; ++_i35) + { + xfer += this->foreignKeys[_i35].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.foreignKeys = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->uniqueConstraints.clear(); + uint32_t _size36; + ::apache::thrift::protocol::TType _etype39; + xfer += iprot->readListBegin(_etype39, _size36); + this->uniqueConstraints.resize(_size36); + uint32_t _i40; + for (_i40 = 0; _i40 < _size36; ++_i40) + { + xfer += this->uniqueConstraints[_i40].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.uniqueConstraints = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->notNullConstraints.clear(); + uint32_t _size41; + ::apache::thrift::protocol::TType _etype44; + xfer += iprot->readListBegin(_etype44, _size41); + this->notNullConstraints.resize(_size41); + uint32_t _i45; + for (_i45 = 0; _i45 < _size41; ++_i45) + { + xfer += this->notNullConstraints[_i45].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.notNullConstraints = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->defaultConstraints.clear(); + uint32_t _size46; + ::apache::thrift::protocol::TType _etype49; + xfer += iprot->readListBegin(_etype49, _size46); + this->defaultConstraints.resize(_size46); + uint32_t _i50; + for (_i50 = 0; _i50 < _size46; ++_i50) + { + xfer += this->defaultConstraints[_i50].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.defaultConstraints = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->checkConstraints.clear(); + uint32_t _size51; + ::apache::thrift::protocol::TType _etype54; + xfer += iprot->readListBegin(_etype54, _size51); + this->checkConstraints.resize(_size51); + uint32_t _i55; + for (_i55 = 0; _i55 < _size51; ++_i55) + { + xfer += this->checkConstraints[_i55].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.checkConstraints = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t SQLAllTableConstraints::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("SQLAllTableConstraints"); + + if (this->__isset.primaryKeys) { + xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->primaryKeys.size())); + std::vector ::const_iterator _iter56; + for (_iter56 = this->primaryKeys.begin(); _iter56 != this->primaryKeys.end(); ++_iter56) + { + xfer += (*_iter56).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.foreignKeys) { + xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->foreignKeys.size())); + std::vector ::const_iterator _iter57; + for (_iter57 = this->foreignKeys.begin(); _iter57 != this->foreignKeys.end(); ++_iter57) + { + xfer += (*_iter57).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.uniqueConstraints) { + xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->uniqueConstraints.size())); + std::vector ::const_iterator _iter58; + for (_iter58 = this->uniqueConstraints.begin(); _iter58 != this->uniqueConstraints.end(); ++_iter58) + { + xfer += (*_iter58).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.notNullConstraints) { + xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->notNullConstraints.size())); + std::vector ::const_iterator _iter59; + for (_iter59 = this->notNullConstraints.begin(); _iter59 != this->notNullConstraints.end(); ++_iter59) + { + xfer += (*_iter59).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.defaultConstraints) { + xfer += oprot->writeFieldBegin("defaultConstraints", ::apache::thrift::protocol::T_LIST, 5); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->defaultConstraints.size())); + std::vector ::const_iterator _iter60; + for (_iter60 = this->defaultConstraints.begin(); _iter60 != this->defaultConstraints.end(); ++_iter60) + { + xfer += (*_iter60).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.checkConstraints) { + xfer += oprot->writeFieldBegin("checkConstraints", ::apache::thrift::protocol::T_LIST, 6); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->checkConstraints.size())); + std::vector ::const_iterator _iter61; + for (_iter61 = this->checkConstraints.begin(); _iter61 != this->checkConstraints.end(); ++_iter61) + { + xfer += (*_iter61).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(SQLAllTableConstraints &a, SQLAllTableConstraints &b) noexcept { + using ::std::swap; + swap(a.primaryKeys, b.primaryKeys); + swap(a.foreignKeys, b.foreignKeys); + swap(a.uniqueConstraints, b.uniqueConstraints); + swap(a.notNullConstraints, b.notNullConstraints); + swap(a.defaultConstraints, b.defaultConstraints); + swap(a.checkConstraints, b.checkConstraints); + swap(a.__isset, b.__isset); +} + +bool SQLAllTableConstraints::operator==(const SQLAllTableConstraints & rhs) const +{ + if (__isset.primaryKeys != rhs.__isset.primaryKeys) + return false; + else if (__isset.primaryKeys && !(primaryKeys == rhs.primaryKeys)) + return false; + if (__isset.foreignKeys != rhs.__isset.foreignKeys) + return false; + else if (__isset.foreignKeys && !(foreignKeys == rhs.foreignKeys)) + return false; + if (__isset.uniqueConstraints != rhs.__isset.uniqueConstraints) + return false; + else if (__isset.uniqueConstraints && !(uniqueConstraints == rhs.uniqueConstraints)) + return false; + if (__isset.notNullConstraints != rhs.__isset.notNullConstraints) + return false; + else if (__isset.notNullConstraints && !(notNullConstraints == rhs.notNullConstraints)) + return false; + if (__isset.defaultConstraints != rhs.__isset.defaultConstraints) + return false; + else if (__isset.defaultConstraints && !(defaultConstraints == rhs.defaultConstraints)) + return false; + if (__isset.checkConstraints != rhs.__isset.checkConstraints) + return false; + else if (__isset.checkConstraints && !(checkConstraints == rhs.checkConstraints)) + return false; + return true; +} + +SQLAllTableConstraints::SQLAllTableConstraints(const SQLAllTableConstraints& other62) { + primaryKeys = other62.primaryKeys; + foreignKeys = other62.foreignKeys; + uniqueConstraints = other62.uniqueConstraints; + notNullConstraints = other62.notNullConstraints; + defaultConstraints = other62.defaultConstraints; + checkConstraints = other62.checkConstraints; + __isset = other62.__isset; +} +SQLAllTableConstraints& SQLAllTableConstraints::operator=(const SQLAllTableConstraints& other63) { + primaryKeys = other63.primaryKeys; + foreignKeys = other63.foreignKeys; + uniqueConstraints = other63.uniqueConstraints; + notNullConstraints = other63.notNullConstraints; + defaultConstraints = other63.defaultConstraints; + checkConstraints = other63.checkConstraints; + __isset = other63.__isset; + return *this; +} +void SQLAllTableConstraints::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "SQLAllTableConstraints("; + out << "primaryKeys="; (__isset.primaryKeys ? (out << to_string(primaryKeys)) : (out << "")); + out << ", " << "foreignKeys="; (__isset.foreignKeys ? (out << to_string(foreignKeys)) : (out << "")); + out << ", " << "uniqueConstraints="; (__isset.uniqueConstraints ? (out << to_string(uniqueConstraints)) : (out << "")); + out << ", " << "notNullConstraints="; (__isset.notNullConstraints ? (out << to_string(notNullConstraints)) : (out << "")); + out << ", " << "defaultConstraints="; (__isset.defaultConstraints ? (out << to_string(defaultConstraints)) : (out << "")); + out << ", " << "checkConstraints="; (__isset.checkConstraints ? (out << to_string(checkConstraints)) : (out << "")); + out << ")"; +} + + +Type::~Type() noexcept { +} + +Type::Type() noexcept + : name(), + type1(), + type2() { +} + +void Type::__set_name(const std::string& val) { + this->name = val; +} + +void Type::__set_type1(const std::string& val) { + this->type1 = val; +__isset.type1 = true; +} + +void Type::__set_type2(const std::string& val) { + this->type2 = val; +__isset.type2 = true; +} + +void Type::__set_fields(const std::vector & val) { + this->fields = val; +__isset.fields = true; +} +std::ostream& operator<<(std::ostream& out, const Type& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Type::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->type1); + this->__isset.type1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->type2); + this->__isset.type2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->fields.clear(); + uint32_t _size64; + ::apache::thrift::protocol::TType _etype67; + xfer += iprot->readListBegin(_etype67, _size64); + this->fields.resize(_size64); + uint32_t _i68; + for (_i68 = 0; _i68 < _size64; ++_i68) + { + xfer += this->fields[_i68].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.fields = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Type::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Type"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.type1) { + xfer += oprot->writeFieldBegin("type1", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->type1); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.type2) { + xfer += oprot->writeFieldBegin("type2", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->type2); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.fields) { + xfer += oprot->writeFieldBegin("fields", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->fields.size())); + std::vector ::const_iterator _iter69; + for (_iter69 = this->fields.begin(); _iter69 != this->fields.end(); ++_iter69) + { + xfer += (*_iter69).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Type &a, Type &b) noexcept { + using ::std::swap; + swap(a.name, b.name); + swap(a.type1, b.type1); + swap(a.type2, b.type2); + swap(a.fields, b.fields); + swap(a.__isset, b.__isset); +} + +bool Type::operator==(const Type & rhs) const +{ + if (!(name == rhs.name)) + return false; + if (__isset.type1 != rhs.__isset.type1) + return false; + else if (__isset.type1 && !(type1 == rhs.type1)) + return false; + if (__isset.type2 != rhs.__isset.type2) + return false; + else if (__isset.type2 && !(type2 == rhs.type2)) + return false; + if (__isset.fields != rhs.__isset.fields) + return false; + else if (__isset.fields && !(fields == rhs.fields)) + return false; + return true; +} + +Type::Type(const Type& other70) { + name = other70.name; + type1 = other70.type1; + type2 = other70.type2; + fields = other70.fields; + __isset = other70.__isset; +} +Type& Type::operator=(const Type& other71) { + name = other71.name; + type1 = other71.type1; + type2 = other71.type2; + fields = other71.fields; + __isset = other71.__isset; + return *this; +} +void Type::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Type("; + out << "name=" << to_string(name); + out << ", " << "type1="; (__isset.type1 ? (out << to_string(type1)) : (out << "")); + out << ", " << "type2="; (__isset.type2 ? (out << to_string(type2)) : (out << "")); + out << ", " << "fields="; (__isset.fields ? (out << to_string(fields)) : (out << "")); + out << ")"; +} + + +PropertySetRequest::~PropertySetRequest() noexcept { +} + +PropertySetRequest::PropertySetRequest() noexcept + : nameSpace() { +} + +void PropertySetRequest::__set_nameSpace(const std::string& val) { + this->nameSpace = val; +} + +void PropertySetRequest::__set_propertyMap(const std::map & val) { + this->propertyMap = val; +} +std::ostream& operator<<(std::ostream& out, const PropertySetRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PropertySetRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_nameSpace = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->nameSpace); + isset_nameSpace = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->propertyMap.clear(); + uint32_t _size72; + ::apache::thrift::protocol::TType _ktype73; + ::apache::thrift::protocol::TType _vtype74; + xfer += iprot->readMapBegin(_ktype73, _vtype74, _size72); + uint32_t _i76; + for (_i76 = 0; _i76 < _size72; ++_i76) + { + std::string _key77; + xfer += iprot->readString(_key77); + std::string& _val78 = this->propertyMap[_key77]; + xfer += iprot->readString(_val78); + } + xfer += iprot->readMapEnd(); + } + this->__isset.propertyMap = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_nameSpace) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t PropertySetRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PropertySetRequest"); + + xfer += oprot->writeFieldBegin("nameSpace", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->nameSpace); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("propertyMap", ::apache::thrift::protocol::T_MAP, 2); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->propertyMap.size())); + std::map ::const_iterator _iter79; + for (_iter79 = this->propertyMap.begin(); _iter79 != this->propertyMap.end(); ++_iter79) + { + xfer += oprot->writeString(_iter79->first); + xfer += oprot->writeString(_iter79->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PropertySetRequest &a, PropertySetRequest &b) noexcept { + using ::std::swap; + swap(a.nameSpace, b.nameSpace); + swap(a.propertyMap, b.propertyMap); + swap(a.__isset, b.__isset); +} + +bool PropertySetRequest::operator==(const PropertySetRequest & rhs) const +{ + if (!(nameSpace == rhs.nameSpace)) + return false; + if (!(propertyMap == rhs.propertyMap)) + return false; + return true; +} + +PropertySetRequest::PropertySetRequest(const PropertySetRequest& other80) { + nameSpace = other80.nameSpace; + propertyMap = other80.propertyMap; + __isset = other80.__isset; +} +PropertySetRequest& PropertySetRequest::operator=(const PropertySetRequest& other81) { + nameSpace = other81.nameSpace; + propertyMap = other81.propertyMap; + __isset = other81.__isset; + return *this; +} +void PropertySetRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PropertySetRequest("; + out << "nameSpace=" << to_string(nameSpace); + out << ", " << "propertyMap=" << to_string(propertyMap); + out << ")"; +} + + +PropertyGetRequest::~PropertyGetRequest() noexcept { +} + +PropertyGetRequest::PropertyGetRequest() noexcept + : nameSpace(), + mapPrefix(), + mapPredicate() { +} + +void PropertyGetRequest::__set_nameSpace(const std::string& val) { + this->nameSpace = val; +} + +void PropertyGetRequest::__set_mapPrefix(const std::string& val) { + this->mapPrefix = val; +} + +void PropertyGetRequest::__set_mapPredicate(const std::string& val) { + this->mapPredicate = val; +__isset.mapPredicate = true; +} + +void PropertyGetRequest::__set_mapSelection(const std::vector & val) { + this->mapSelection = val; +__isset.mapSelection = true; +} +std::ostream& operator<<(std::ostream& out, const PropertyGetRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PropertyGetRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_nameSpace = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->nameSpace); + isset_nameSpace = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->mapPrefix); + this->__isset.mapPrefix = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->mapPredicate); + this->__isset.mapPredicate = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->mapSelection.clear(); + uint32_t _size82; + ::apache::thrift::protocol::TType _etype85; + xfer += iprot->readListBegin(_etype85, _size82); + this->mapSelection.resize(_size82); + uint32_t _i86; + for (_i86 = 0; _i86 < _size82; ++_i86) + { + xfer += iprot->readString(this->mapSelection[_i86]); + } + xfer += iprot->readListEnd(); + } + this->__isset.mapSelection = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_nameSpace) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t PropertyGetRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PropertyGetRequest"); + + xfer += oprot->writeFieldBegin("nameSpace", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->nameSpace); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("mapPrefix", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->mapPrefix); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.mapPredicate) { + xfer += oprot->writeFieldBegin("mapPredicate", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->mapPredicate); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.mapSelection) { + xfer += oprot->writeFieldBegin("mapSelection", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->mapSelection.size())); + std::vector ::const_iterator _iter87; + for (_iter87 = this->mapSelection.begin(); _iter87 != this->mapSelection.end(); ++_iter87) + { + xfer += oprot->writeString((*_iter87)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PropertyGetRequest &a, PropertyGetRequest &b) noexcept { + using ::std::swap; + swap(a.nameSpace, b.nameSpace); + swap(a.mapPrefix, b.mapPrefix); + swap(a.mapPredicate, b.mapPredicate); + swap(a.mapSelection, b.mapSelection); + swap(a.__isset, b.__isset); +} + +bool PropertyGetRequest::operator==(const PropertyGetRequest & rhs) const +{ + if (!(nameSpace == rhs.nameSpace)) + return false; + if (!(mapPrefix == rhs.mapPrefix)) + return false; + if (__isset.mapPredicate != rhs.__isset.mapPredicate) + return false; + else if (__isset.mapPredicate && !(mapPredicate == rhs.mapPredicate)) + return false; + if (__isset.mapSelection != rhs.__isset.mapSelection) + return false; + else if (__isset.mapSelection && !(mapSelection == rhs.mapSelection)) + return false; + return true; +} + +PropertyGetRequest::PropertyGetRequest(const PropertyGetRequest& other88) { + nameSpace = other88.nameSpace; + mapPrefix = other88.mapPrefix; + mapPredicate = other88.mapPredicate; + mapSelection = other88.mapSelection; + __isset = other88.__isset; +} +PropertyGetRequest& PropertyGetRequest::operator=(const PropertyGetRequest& other89) { + nameSpace = other89.nameSpace; + mapPrefix = other89.mapPrefix; + mapPredicate = other89.mapPredicate; + mapSelection = other89.mapSelection; + __isset = other89.__isset; + return *this; +} +void PropertyGetRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PropertyGetRequest("; + out << "nameSpace=" << to_string(nameSpace); + out << ", " << "mapPrefix=" << to_string(mapPrefix); + out << ", " << "mapPredicate="; (__isset.mapPredicate ? (out << to_string(mapPredicate)) : (out << "")); + out << ", " << "mapSelection="; (__isset.mapSelection ? (out << to_string(mapSelection)) : (out << "")); + out << ")"; +} + + +PropertyGetResponse::~PropertyGetResponse() noexcept { +} + +PropertyGetResponse::PropertyGetResponse() noexcept { +} + +void PropertyGetResponse::__set_properties(const std::map > & val) { + this->properties = val; +} +std::ostream& operator<<(std::ostream& out, const PropertyGetResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PropertyGetResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->properties.clear(); + uint32_t _size90; + ::apache::thrift::protocol::TType _ktype91; + ::apache::thrift::protocol::TType _vtype92; + xfer += iprot->readMapBegin(_ktype91, _vtype92, _size90); + uint32_t _i94; + for (_i94 = 0; _i94 < _size90; ++_i94) + { + std::string _key95; + xfer += iprot->readString(_key95); + std::map & _val96 = this->properties[_key95]; + { + _val96.clear(); + uint32_t _size97; + ::apache::thrift::protocol::TType _ktype98; + ::apache::thrift::protocol::TType _vtype99; + xfer += iprot->readMapBegin(_ktype98, _vtype99, _size97); + uint32_t _i101; + for (_i101 = 0; _i101 < _size97; ++_i101) + { + std::string _key102; + xfer += iprot->readString(_key102); + std::string& _val103 = _val96[_key102]; + xfer += iprot->readString(_val103); + } + xfer += iprot->readMapEnd(); + } + } + xfer += iprot->readMapEnd(); + } + this->__isset.properties = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t PropertyGetResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PropertyGetResponse"); + + xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 1); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_MAP, static_cast(this->properties.size())); + std::map > ::const_iterator _iter104; + for (_iter104 = this->properties.begin(); _iter104 != this->properties.end(); ++_iter104) + { + xfer += oprot->writeString(_iter104->first); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(_iter104->second.size())); + std::map ::const_iterator _iter105; + for (_iter105 = _iter104->second.begin(); _iter105 != _iter104->second.end(); ++_iter105) + { + xfer += oprot->writeString(_iter105->first); + xfer += oprot->writeString(_iter105->second); + } + xfer += oprot->writeMapEnd(); + } + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PropertyGetResponse &a, PropertyGetResponse &b) noexcept { + using ::std::swap; + swap(a.properties, b.properties); + swap(a.__isset, b.__isset); +} + +bool PropertyGetResponse::operator==(const PropertyGetResponse & rhs) const +{ + if (!(properties == rhs.properties)) + return false; + return true; +} + +PropertyGetResponse::PropertyGetResponse(const PropertyGetResponse& other106) { + properties = other106.properties; + __isset = other106.__isset; +} +PropertyGetResponse& PropertyGetResponse::operator=(const PropertyGetResponse& other107) { + properties = other107.properties; + __isset = other107.__isset; + return *this; +} +void PropertyGetResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PropertyGetResponse("; + out << "properties=" << to_string(properties); + out << ")"; +} + + +HiveObjectRef::~HiveObjectRef() noexcept { +} + +HiveObjectRef::HiveObjectRef() noexcept + : objectType(static_cast(0)), + dbName(), + objectName(), + columnName(), + catName() { +} + +void HiveObjectRef::__set_objectType(const HiveObjectType::type val) { + this->objectType = val; +} + +void HiveObjectRef::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void HiveObjectRef::__set_objectName(const std::string& val) { + this->objectName = val; +} + +void HiveObjectRef::__set_partValues(const std::vector & val) { + this->partValues = val; +} + +void HiveObjectRef::__set_columnName(const std::string& val) { + this->columnName = val; +} + +void HiveObjectRef::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} +std::ostream& operator<<(std::ostream& out, const HiveObjectRef& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t HiveObjectRef::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast108; + xfer += iprot->readI32(ecast108); + this->objectType = static_cast(ecast108); + this->__isset.objectType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->objectName); + this->__isset.objectName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partValues.clear(); + uint32_t _size109; + ::apache::thrift::protocol::TType _etype112; + xfer += iprot->readListBegin(_etype112, _size109); + this->partValues.resize(_size109); + uint32_t _i113; + for (_i113 = 0; _i113 < _size109; ++_i113) + { + xfer += iprot->readString(this->partValues[_i113]); + } + xfer += iprot->readListEnd(); + } + this->__isset.partValues = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->columnName); + this->__isset.columnName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t HiveObjectRef::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("HiveObjectRef"); + + xfer += oprot->writeFieldBegin("objectType", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32(static_cast(this->objectType)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("objectName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->objectName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("partValues", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partValues.size())); + std::vector ::const_iterator _iter114; + for (_iter114 = this->partValues.begin(); _iter114 != this->partValues.end(); ++_iter114) + { + xfer += oprot->writeString((*_iter114)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("columnName", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->columnName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(HiveObjectRef &a, HiveObjectRef &b) noexcept { + using ::std::swap; + swap(a.objectType, b.objectType); + swap(a.dbName, b.dbName); + swap(a.objectName, b.objectName); + swap(a.partValues, b.partValues); + swap(a.columnName, b.columnName); + swap(a.catName, b.catName); + swap(a.__isset, b.__isset); +} + +bool HiveObjectRef::operator==(const HiveObjectRef & rhs) const +{ + if (!(objectType == rhs.objectType)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(objectName == rhs.objectName)) + return false; + if (!(partValues == rhs.partValues)) + return false; + if (!(columnName == rhs.columnName)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + return true; +} + +HiveObjectRef::HiveObjectRef(const HiveObjectRef& other115) { + objectType = other115.objectType; + dbName = other115.dbName; + objectName = other115.objectName; + partValues = other115.partValues; + columnName = other115.columnName; + catName = other115.catName; + __isset = other115.__isset; +} +HiveObjectRef& HiveObjectRef::operator=(const HiveObjectRef& other116) { + objectType = other116.objectType; + dbName = other116.dbName; + objectName = other116.objectName; + partValues = other116.partValues; + columnName = other116.columnName; + catName = other116.catName; + __isset = other116.__isset; + return *this; +} +void HiveObjectRef::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "HiveObjectRef("; + out << "objectType=" << to_string(objectType); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "objectName=" << to_string(objectName); + out << ", " << "partValues=" << to_string(partValues); + out << ", " << "columnName=" << to_string(columnName); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ")"; +} + + +PrivilegeGrantInfo::~PrivilegeGrantInfo() noexcept { +} + +PrivilegeGrantInfo::PrivilegeGrantInfo() noexcept + : privilege(), + createTime(0), + grantor(), + grantorType(static_cast(0)), + grantOption(0) { +} + +void PrivilegeGrantInfo::__set_privilege(const std::string& val) { + this->privilege = val; +} + +void PrivilegeGrantInfo::__set_createTime(const int32_t val) { + this->createTime = val; +} + +void PrivilegeGrantInfo::__set_grantor(const std::string& val) { + this->grantor = val; +} + +void PrivilegeGrantInfo::__set_grantorType(const PrincipalType::type val) { + this->grantorType = val; +} + +void PrivilegeGrantInfo::__set_grantOption(const bool val) { + this->grantOption = val; +} +std::ostream& operator<<(std::ostream& out, const PrivilegeGrantInfo& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PrivilegeGrantInfo::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->privilege); + this->__isset.privilege = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->createTime); + this->__isset.createTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->grantor); + this->__isset.grantor = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast117; + xfer += iprot->readI32(ecast117); + this->grantorType = static_cast(ecast117); + this->__isset.grantorType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->grantOption); + this->__isset.grantOption = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t PrivilegeGrantInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PrivilegeGrantInfo"); + + xfer += oprot->writeFieldBegin("privilege", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->privilege); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("createTime", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(this->createTime); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("grantor", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->grantor); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("grantorType", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32(static_cast(this->grantorType)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("grantOption", ::apache::thrift::protocol::T_BOOL, 5); + xfer += oprot->writeBool(this->grantOption); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PrivilegeGrantInfo &a, PrivilegeGrantInfo &b) noexcept { + using ::std::swap; + swap(a.privilege, b.privilege); + swap(a.createTime, b.createTime); + swap(a.grantor, b.grantor); + swap(a.grantorType, b.grantorType); + swap(a.grantOption, b.grantOption); + swap(a.__isset, b.__isset); +} + +bool PrivilegeGrantInfo::operator==(const PrivilegeGrantInfo & rhs) const +{ + if (!(privilege == rhs.privilege)) + return false; + if (!(createTime == rhs.createTime)) + return false; + if (!(grantor == rhs.grantor)) + return false; + if (!(grantorType == rhs.grantorType)) + return false; + if (!(grantOption == rhs.grantOption)) + return false; + return true; +} + +PrivilegeGrantInfo::PrivilegeGrantInfo(const PrivilegeGrantInfo& other118) { + privilege = other118.privilege; + createTime = other118.createTime; + grantor = other118.grantor; + grantorType = other118.grantorType; + grantOption = other118.grantOption; + __isset = other118.__isset; +} +PrivilegeGrantInfo& PrivilegeGrantInfo::operator=(const PrivilegeGrantInfo& other119) { + privilege = other119.privilege; + createTime = other119.createTime; + grantor = other119.grantor; + grantorType = other119.grantorType; + grantOption = other119.grantOption; + __isset = other119.__isset; + return *this; +} +void PrivilegeGrantInfo::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PrivilegeGrantInfo("; + out << "privilege=" << to_string(privilege); + out << ", " << "createTime=" << to_string(createTime); + out << ", " << "grantor=" << to_string(grantor); + out << ", " << "grantorType=" << to_string(grantorType); + out << ", " << "grantOption=" << to_string(grantOption); + out << ")"; +} + + +HiveObjectPrivilege::~HiveObjectPrivilege() noexcept { +} + +HiveObjectPrivilege::HiveObjectPrivilege() noexcept + : principalName(), + principalType(static_cast(0)), + authorizer() { +} + +void HiveObjectPrivilege::__set_hiveObject(const HiveObjectRef& val) { + this->hiveObject = val; +} + +void HiveObjectPrivilege::__set_principalName(const std::string& val) { + this->principalName = val; +} + +void HiveObjectPrivilege::__set_principalType(const PrincipalType::type val) { + this->principalType = val; +} + +void HiveObjectPrivilege::__set_grantInfo(const PrivilegeGrantInfo& val) { + this->grantInfo = val; +} + +void HiveObjectPrivilege::__set_authorizer(const std::string& val) { + this->authorizer = val; +} +std::ostream& operator<<(std::ostream& out, const HiveObjectPrivilege& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t HiveObjectPrivilege::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->hiveObject.read(iprot); + this->__isset.hiveObject = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->principalName); + this->__isset.principalName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast120; + xfer += iprot->readI32(ecast120); + this->principalType = static_cast(ecast120); + this->__isset.principalType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->grantInfo.read(iprot); + this->__isset.grantInfo = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->authorizer); + this->__isset.authorizer = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t HiveObjectPrivilege::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("HiveObjectPrivilege"); + + xfer += oprot->writeFieldBegin("hiveObject", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->hiveObject.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principalName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->principalName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principalType", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32(static_cast(this->principalType)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("grantInfo", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->grantInfo.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("authorizer", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->authorizer); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(HiveObjectPrivilege &a, HiveObjectPrivilege &b) noexcept { + using ::std::swap; + swap(a.hiveObject, b.hiveObject); + swap(a.principalName, b.principalName); + swap(a.principalType, b.principalType); + swap(a.grantInfo, b.grantInfo); + swap(a.authorizer, b.authorizer); + swap(a.__isset, b.__isset); +} + +bool HiveObjectPrivilege::operator==(const HiveObjectPrivilege & rhs) const +{ + if (!(hiveObject == rhs.hiveObject)) + return false; + if (!(principalName == rhs.principalName)) + return false; + if (!(principalType == rhs.principalType)) + return false; + if (!(grantInfo == rhs.grantInfo)) + return false; + if (!(authorizer == rhs.authorizer)) + return false; + return true; +} + +HiveObjectPrivilege::HiveObjectPrivilege(const HiveObjectPrivilege& other121) { + hiveObject = other121.hiveObject; + principalName = other121.principalName; + principalType = other121.principalType; + grantInfo = other121.grantInfo; + authorizer = other121.authorizer; + __isset = other121.__isset; +} +HiveObjectPrivilege& HiveObjectPrivilege::operator=(const HiveObjectPrivilege& other122) { + hiveObject = other122.hiveObject; + principalName = other122.principalName; + principalType = other122.principalType; + grantInfo = other122.grantInfo; + authorizer = other122.authorizer; + __isset = other122.__isset; + return *this; +} +void HiveObjectPrivilege::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "HiveObjectPrivilege("; + out << "hiveObject=" << to_string(hiveObject); + out << ", " << "principalName=" << to_string(principalName); + out << ", " << "principalType=" << to_string(principalType); + out << ", " << "grantInfo=" << to_string(grantInfo); + out << ", " << "authorizer=" << to_string(authorizer); + out << ")"; +} + + +PrivilegeBag::~PrivilegeBag() noexcept { +} + +PrivilegeBag::PrivilegeBag() noexcept { +} + +void PrivilegeBag::__set_privileges(const std::vector & val) { + this->privileges = val; +} +std::ostream& operator<<(std::ostream& out, const PrivilegeBag& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PrivilegeBag::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->privileges.clear(); + uint32_t _size123; + ::apache::thrift::protocol::TType _etype126; + xfer += iprot->readListBegin(_etype126, _size123); + this->privileges.resize(_size123); + uint32_t _i127; + for (_i127 = 0; _i127 < _size123; ++_i127) + { + xfer += this->privileges[_i127].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.privileges = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t PrivilegeBag::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PrivilegeBag"); + + xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->privileges.size())); + std::vector ::const_iterator _iter128; + for (_iter128 = this->privileges.begin(); _iter128 != this->privileges.end(); ++_iter128) + { + xfer += (*_iter128).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PrivilegeBag &a, PrivilegeBag &b) noexcept { + using ::std::swap; + swap(a.privileges, b.privileges); + swap(a.__isset, b.__isset); +} + +bool PrivilegeBag::operator==(const PrivilegeBag & rhs) const +{ + if (!(privileges == rhs.privileges)) + return false; + return true; +} + +PrivilegeBag::PrivilegeBag(const PrivilegeBag& other129) { + privileges = other129.privileges; + __isset = other129.__isset; +} +PrivilegeBag& PrivilegeBag::operator=(const PrivilegeBag& other130) { + privileges = other130.privileges; + __isset = other130.__isset; + return *this; +} +void PrivilegeBag::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PrivilegeBag("; + out << "privileges=" << to_string(privileges); + out << ")"; +} + + +PrincipalPrivilegeSet::~PrincipalPrivilegeSet() noexcept { +} + +PrincipalPrivilegeSet::PrincipalPrivilegeSet() noexcept { +} + +void PrincipalPrivilegeSet::__set_userPrivileges(const std::map > & val) { + this->userPrivileges = val; +} + +void PrincipalPrivilegeSet::__set_groupPrivileges(const std::map > & val) { + this->groupPrivileges = val; +} + +void PrincipalPrivilegeSet::__set_rolePrivileges(const std::map > & val) { + this->rolePrivileges = val; +} +std::ostream& operator<<(std::ostream& out, const PrincipalPrivilegeSet& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PrincipalPrivilegeSet::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->userPrivileges.clear(); + uint32_t _size131; + ::apache::thrift::protocol::TType _ktype132; + ::apache::thrift::protocol::TType _vtype133; + xfer += iprot->readMapBegin(_ktype132, _vtype133, _size131); + uint32_t _i135; + for (_i135 = 0; _i135 < _size131; ++_i135) + { + std::string _key136; + xfer += iprot->readString(_key136); + std::vector & _val137 = this->userPrivileges[_key136]; + { + _val137.clear(); + uint32_t _size138; + ::apache::thrift::protocol::TType _etype141; + xfer += iprot->readListBegin(_etype141, _size138); + _val137.resize(_size138); + uint32_t _i142; + for (_i142 = 0; _i142 < _size138; ++_i142) + { + xfer += _val137[_i142].read(iprot); + } + xfer += iprot->readListEnd(); + } + } + xfer += iprot->readMapEnd(); + } + this->__isset.userPrivileges = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->groupPrivileges.clear(); + uint32_t _size143; + ::apache::thrift::protocol::TType _ktype144; + ::apache::thrift::protocol::TType _vtype145; + xfer += iprot->readMapBegin(_ktype144, _vtype145, _size143); + uint32_t _i147; + for (_i147 = 0; _i147 < _size143; ++_i147) + { + std::string _key148; + xfer += iprot->readString(_key148); + std::vector & _val149 = this->groupPrivileges[_key148]; + { + _val149.clear(); + uint32_t _size150; + ::apache::thrift::protocol::TType _etype153; + xfer += iprot->readListBegin(_etype153, _size150); + _val149.resize(_size150); + uint32_t _i154; + for (_i154 = 0; _i154 < _size150; ++_i154) + { + xfer += _val149[_i154].read(iprot); + } + xfer += iprot->readListEnd(); + } + } + xfer += iprot->readMapEnd(); + } + this->__isset.groupPrivileges = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->rolePrivileges.clear(); + uint32_t _size155; + ::apache::thrift::protocol::TType _ktype156; + ::apache::thrift::protocol::TType _vtype157; + xfer += iprot->readMapBegin(_ktype156, _vtype157, _size155); + uint32_t _i159; + for (_i159 = 0; _i159 < _size155; ++_i159) + { + std::string _key160; + xfer += iprot->readString(_key160); + std::vector & _val161 = this->rolePrivileges[_key160]; + { + _val161.clear(); + uint32_t _size162; + ::apache::thrift::protocol::TType _etype165; + xfer += iprot->readListBegin(_etype165, _size162); + _val161.resize(_size162); + uint32_t _i166; + for (_i166 = 0; _i166 < _size162; ++_i166) + { + xfer += _val161[_i166].read(iprot); + } + xfer += iprot->readListEnd(); + } + } + xfer += iprot->readMapEnd(); + } + this->__isset.rolePrivileges = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t PrincipalPrivilegeSet::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PrincipalPrivilegeSet"); + + xfer += oprot->writeFieldBegin("userPrivileges", ::apache::thrift::protocol::T_MAP, 1); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast(this->userPrivileges.size())); + std::map > ::const_iterator _iter167; + for (_iter167 = this->userPrivileges.begin(); _iter167 != this->userPrivileges.end(); ++_iter167) + { + xfer += oprot->writeString(_iter167->first); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter167->second.size())); + std::vector ::const_iterator _iter168; + for (_iter168 = _iter167->second.begin(); _iter168 != _iter167->second.end(); ++_iter168) + { + xfer += (*_iter168).write(oprot); + } + xfer += oprot->writeListEnd(); + } + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("groupPrivileges", ::apache::thrift::protocol::T_MAP, 2); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast(this->groupPrivileges.size())); + std::map > ::const_iterator _iter169; + for (_iter169 = this->groupPrivileges.begin(); _iter169 != this->groupPrivileges.end(); ++_iter169) + { + xfer += oprot->writeString(_iter169->first); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter169->second.size())); + std::vector ::const_iterator _iter170; + for (_iter170 = _iter169->second.begin(); _iter170 != _iter169->second.end(); ++_iter170) + { + xfer += (*_iter170).write(oprot); + } + xfer += oprot->writeListEnd(); + } + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("rolePrivileges", ::apache::thrift::protocol::T_MAP, 3); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast(this->rolePrivileges.size())); + std::map > ::const_iterator _iter171; + for (_iter171 = this->rolePrivileges.begin(); _iter171 != this->rolePrivileges.end(); ++_iter171) + { + xfer += oprot->writeString(_iter171->first); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter171->second.size())); + std::vector ::const_iterator _iter172; + for (_iter172 = _iter171->second.begin(); _iter172 != _iter171->second.end(); ++_iter172) + { + xfer += (*_iter172).write(oprot); + } + xfer += oprot->writeListEnd(); + } + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PrincipalPrivilegeSet &a, PrincipalPrivilegeSet &b) noexcept { + using ::std::swap; + swap(a.userPrivileges, b.userPrivileges); + swap(a.groupPrivileges, b.groupPrivileges); + swap(a.rolePrivileges, b.rolePrivileges); + swap(a.__isset, b.__isset); +} + +bool PrincipalPrivilegeSet::operator==(const PrincipalPrivilegeSet & rhs) const +{ + if (!(userPrivileges == rhs.userPrivileges)) + return false; + if (!(groupPrivileges == rhs.groupPrivileges)) + return false; + if (!(rolePrivileges == rhs.rolePrivileges)) + return false; + return true; +} + +PrincipalPrivilegeSet::PrincipalPrivilegeSet(const PrincipalPrivilegeSet& other173) { + userPrivileges = other173.userPrivileges; + groupPrivileges = other173.groupPrivileges; + rolePrivileges = other173.rolePrivileges; + __isset = other173.__isset; +} +PrincipalPrivilegeSet& PrincipalPrivilegeSet::operator=(const PrincipalPrivilegeSet& other174) { + userPrivileges = other174.userPrivileges; + groupPrivileges = other174.groupPrivileges; + rolePrivileges = other174.rolePrivileges; + __isset = other174.__isset; + return *this; +} +void PrincipalPrivilegeSet::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PrincipalPrivilegeSet("; + out << "userPrivileges=" << to_string(userPrivileges); + out << ", " << "groupPrivileges=" << to_string(groupPrivileges); + out << ", " << "rolePrivileges=" << to_string(rolePrivileges); + out << ")"; +} + + +GrantRevokePrivilegeRequest::~GrantRevokePrivilegeRequest() noexcept { +} + +GrantRevokePrivilegeRequest::GrantRevokePrivilegeRequest() noexcept + : requestType(static_cast(0)), + revokeGrantOption(0) { +} + +void GrantRevokePrivilegeRequest::__set_requestType(const GrantRevokeType::type val) { + this->requestType = val; +} + +void GrantRevokePrivilegeRequest::__set_privileges(const PrivilegeBag& val) { + this->privileges = val; +} + +void GrantRevokePrivilegeRequest::__set_revokeGrantOption(const bool val) { + this->revokeGrantOption = val; +__isset.revokeGrantOption = true; +} +std::ostream& operator<<(std::ostream& out, const GrantRevokePrivilegeRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GrantRevokePrivilegeRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast175; + xfer += iprot->readI32(ecast175); + this->requestType = static_cast(ecast175); + this->__isset.requestType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->privileges.read(iprot); + this->__isset.privileges = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->revokeGrantOption); + this->__isset.revokeGrantOption = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t GrantRevokePrivilegeRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GrantRevokePrivilegeRequest"); + + xfer += oprot->writeFieldBegin("requestType", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32(static_cast(this->requestType)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->privileges.write(oprot); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.revokeGrantOption) { + xfer += oprot->writeFieldBegin("revokeGrantOption", ::apache::thrift::protocol::T_BOOL, 3); + xfer += oprot->writeBool(this->revokeGrantOption); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GrantRevokePrivilegeRequest &a, GrantRevokePrivilegeRequest &b) noexcept { + using ::std::swap; + swap(a.requestType, b.requestType); + swap(a.privileges, b.privileges); + swap(a.revokeGrantOption, b.revokeGrantOption); + swap(a.__isset, b.__isset); +} + +bool GrantRevokePrivilegeRequest::operator==(const GrantRevokePrivilegeRequest & rhs) const +{ + if (!(requestType == rhs.requestType)) + return false; + if (!(privileges == rhs.privileges)) + return false; + if (__isset.revokeGrantOption != rhs.__isset.revokeGrantOption) + return false; + else if (__isset.revokeGrantOption && !(revokeGrantOption == rhs.revokeGrantOption)) + return false; + return true; +} + +GrantRevokePrivilegeRequest::GrantRevokePrivilegeRequest(const GrantRevokePrivilegeRequest& other176) { + requestType = other176.requestType; + privileges = other176.privileges; + revokeGrantOption = other176.revokeGrantOption; + __isset = other176.__isset; +} +GrantRevokePrivilegeRequest& GrantRevokePrivilegeRequest::operator=(const GrantRevokePrivilegeRequest& other177) { + requestType = other177.requestType; + privileges = other177.privileges; + revokeGrantOption = other177.revokeGrantOption; + __isset = other177.__isset; + return *this; +} +void GrantRevokePrivilegeRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GrantRevokePrivilegeRequest("; + out << "requestType=" << to_string(requestType); + out << ", " << "privileges=" << to_string(privileges); + out << ", " << "revokeGrantOption="; (__isset.revokeGrantOption ? (out << to_string(revokeGrantOption)) : (out << "")); + out << ")"; +} + + +GrantRevokePrivilegeResponse::~GrantRevokePrivilegeResponse() noexcept { +} + +GrantRevokePrivilegeResponse::GrantRevokePrivilegeResponse() noexcept + : success(0) { +} + +void GrantRevokePrivilegeResponse::__set_success(const bool val) { + this->success = val; +__isset.success = true; +} +std::ostream& operator<<(std::ostream& out, const GrantRevokePrivilegeResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GrantRevokePrivilegeResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t GrantRevokePrivilegeResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GrantRevokePrivilegeResponse"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 1); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GrantRevokePrivilegeResponse &a, GrantRevokePrivilegeResponse &b) noexcept { + using ::std::swap; + swap(a.success, b.success); + swap(a.__isset, b.__isset); +} + +bool GrantRevokePrivilegeResponse::operator==(const GrantRevokePrivilegeResponse & rhs) const +{ + if (__isset.success != rhs.__isset.success) + return false; + else if (__isset.success && !(success == rhs.success)) + return false; + return true; +} + +GrantRevokePrivilegeResponse::GrantRevokePrivilegeResponse(const GrantRevokePrivilegeResponse& other178) noexcept { + success = other178.success; + __isset = other178.__isset; +} +GrantRevokePrivilegeResponse& GrantRevokePrivilegeResponse::operator=(const GrantRevokePrivilegeResponse& other179) noexcept { + success = other179.success; + __isset = other179.__isset; + return *this; +} +void GrantRevokePrivilegeResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GrantRevokePrivilegeResponse("; + out << "success="; (__isset.success ? (out << to_string(success)) : (out << "")); + out << ")"; +} + + +TruncateTableRequest::~TruncateTableRequest() noexcept { +} + +TruncateTableRequest::TruncateTableRequest() noexcept + : dbName(), + tableName(), + writeId(-1LL), + validWriteIdList() { +} + +void TruncateTableRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void TruncateTableRequest::__set_tableName(const std::string& val) { + this->tableName = val; +} + +void TruncateTableRequest::__set_partNames(const std::vector & val) { + this->partNames = val; +__isset.partNames = true; +} + +void TruncateTableRequest::__set_writeId(const int64_t val) { + this->writeId = val; +__isset.writeId = true; +} + +void TruncateTableRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void TruncateTableRequest::__set_environmentContext(const EnvironmentContext& val) { + this->environmentContext = val; +__isset.environmentContext = true; +} +std::ostream& operator<<(std::ostream& out, const TruncateTableRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t TruncateTableRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tableName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + isset_tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partNames.clear(); + uint32_t _size180; + ::apache::thrift::protocol::TType _etype183; + xfer += iprot->readListBegin(_etype183, _size180); + this->partNames.resize(_size180); + uint32_t _i184; + for (_i184 = 0; _i184 < _size180; ++_i184) + { + xfer += iprot->readString(this->partNames[_i184]); + } + xfer += iprot->readListEnd(); + } + this->__isset.partNames = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->writeId); + this->__isset.writeId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->environmentContext.read(iprot); + this->__isset.environmentContext = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tableName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t TruncateTableRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("TruncateTableRequest"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.partNames) { + xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partNames.size())); + std::vector ::const_iterator _iter185; + for (_iter185 = this->partNames.begin(); _iter185 != this->partNames.end(); ++_iter185) + { + xfer += oprot->writeString((*_iter185)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.writeId) { + xfer += oprot->writeFieldBegin("writeId", ::apache::thrift::protocol::T_I64, 4); + xfer += oprot->writeI64(this->writeId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.environmentContext) { + xfer += oprot->writeFieldBegin("environmentContext", ::apache::thrift::protocol::T_STRUCT, 6); + xfer += this->environmentContext.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(TruncateTableRequest &a, TruncateTableRequest &b) noexcept { + using ::std::swap; + swap(a.dbName, b.dbName); + swap(a.tableName, b.tableName); + swap(a.partNames, b.partNames); + swap(a.writeId, b.writeId); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.environmentContext, b.environmentContext); + swap(a.__isset, b.__isset); +} + +bool TruncateTableRequest::operator==(const TruncateTableRequest & rhs) const +{ + if (!(dbName == rhs.dbName)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (__isset.partNames != rhs.__isset.partNames) + return false; + else if (__isset.partNames && !(partNames == rhs.partNames)) + return false; + if (__isset.writeId != rhs.__isset.writeId) + return false; + else if (__isset.writeId && !(writeId == rhs.writeId)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.environmentContext != rhs.__isset.environmentContext) + return false; + else if (__isset.environmentContext && !(environmentContext == rhs.environmentContext)) + return false; + return true; +} + +TruncateTableRequest::TruncateTableRequest(const TruncateTableRequest& other186) { + dbName = other186.dbName; + tableName = other186.tableName; + partNames = other186.partNames; + writeId = other186.writeId; + validWriteIdList = other186.validWriteIdList; + environmentContext = other186.environmentContext; + __isset = other186.__isset; +} +TruncateTableRequest& TruncateTableRequest::operator=(const TruncateTableRequest& other187) { + dbName = other187.dbName; + tableName = other187.tableName; + partNames = other187.partNames; + writeId = other187.writeId; + validWriteIdList = other187.validWriteIdList; + environmentContext = other187.environmentContext; + __isset = other187.__isset; + return *this; +} +void TruncateTableRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "TruncateTableRequest("; + out << "dbName=" << to_string(dbName); + out << ", " << "tableName=" << to_string(tableName); + out << ", " << "partNames="; (__isset.partNames ? (out << to_string(partNames)) : (out << "")); + out << ", " << "writeId="; (__isset.writeId ? (out << to_string(writeId)) : (out << "")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "environmentContext="; (__isset.environmentContext ? (out << to_string(environmentContext)) : (out << "")); + out << ")"; +} + + +TruncateTableResponse::~TruncateTableResponse() noexcept { +} + +TruncateTableResponse::TruncateTableResponse() noexcept { +} +std::ostream& operator<<(std::ostream& out, const TruncateTableResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t TruncateTableResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t TruncateTableResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("TruncateTableResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(TruncateTableResponse &a, TruncateTableResponse &b) noexcept { + using ::std::swap; + (void) a; + (void) b; +} + +bool TruncateTableResponse::operator==(const TruncateTableResponse & /* rhs */) const +{ + return true; +} + +TruncateTableResponse::TruncateTableResponse(const TruncateTableResponse& other188) noexcept { + (void) other188; +} +TruncateTableResponse& TruncateTableResponse::operator=(const TruncateTableResponse& other189) noexcept { + (void) other189; + return *this; +} +void TruncateTableResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "TruncateTableResponse("; + out << ")"; +} + + +Role::~Role() noexcept { +} + +Role::Role() noexcept + : roleName(), + createTime(0), + ownerName() { +} + +void Role::__set_roleName(const std::string& val) { + this->roleName = val; +} + +void Role::__set_createTime(const int32_t val) { + this->createTime = val; +} + +void Role::__set_ownerName(const std::string& val) { + this->ownerName = val; +} +std::ostream& operator<<(std::ostream& out, const Role& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Role::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->roleName); + this->__isset.roleName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->createTime); + this->__isset.createTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ownerName); + this->__isset.ownerName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Role::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Role"); + + xfer += oprot->writeFieldBegin("roleName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->roleName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("createTime", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(this->createTime); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("ownerName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->ownerName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Role &a, Role &b) noexcept { + using ::std::swap; + swap(a.roleName, b.roleName); + swap(a.createTime, b.createTime); + swap(a.ownerName, b.ownerName); + swap(a.__isset, b.__isset); +} + +bool Role::operator==(const Role & rhs) const +{ + if (!(roleName == rhs.roleName)) + return false; + if (!(createTime == rhs.createTime)) + return false; + if (!(ownerName == rhs.ownerName)) + return false; + return true; +} + +Role::Role(const Role& other190) { + roleName = other190.roleName; + createTime = other190.createTime; + ownerName = other190.ownerName; + __isset = other190.__isset; +} +Role& Role::operator=(const Role& other191) { + roleName = other191.roleName; + createTime = other191.createTime; + ownerName = other191.ownerName; + __isset = other191.__isset; + return *this; +} +void Role::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Role("; + out << "roleName=" << to_string(roleName); + out << ", " << "createTime=" << to_string(createTime); + out << ", " << "ownerName=" << to_string(ownerName); + out << ")"; +} + + +RolePrincipalGrant::~RolePrincipalGrant() noexcept { +} + +RolePrincipalGrant::RolePrincipalGrant() noexcept + : roleName(), + principalName(), + principalType(static_cast(0)), + grantOption(0), + grantTime(0), + grantorName(), + grantorPrincipalType(static_cast(0)) { +} + +void RolePrincipalGrant::__set_roleName(const std::string& val) { + this->roleName = val; +} + +void RolePrincipalGrant::__set_principalName(const std::string& val) { + this->principalName = val; +} + +void RolePrincipalGrant::__set_principalType(const PrincipalType::type val) { + this->principalType = val; +} + +void RolePrincipalGrant::__set_grantOption(const bool val) { + this->grantOption = val; +} + +void RolePrincipalGrant::__set_grantTime(const int32_t val) { + this->grantTime = val; +} + +void RolePrincipalGrant::__set_grantorName(const std::string& val) { + this->grantorName = val; +} + +void RolePrincipalGrant::__set_grantorPrincipalType(const PrincipalType::type val) { + this->grantorPrincipalType = val; +} +std::ostream& operator<<(std::ostream& out, const RolePrincipalGrant& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t RolePrincipalGrant::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->roleName); + this->__isset.roleName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->principalName); + this->__isset.principalName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast192; + xfer += iprot->readI32(ecast192); + this->principalType = static_cast(ecast192); + this->__isset.principalType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->grantOption); + this->__isset.grantOption = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->grantTime); + this->__isset.grantTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->grantorName); + this->__isset.grantorName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast193; + xfer += iprot->readI32(ecast193); + this->grantorPrincipalType = static_cast(ecast193); + this->__isset.grantorPrincipalType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t RolePrincipalGrant::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("RolePrincipalGrant"); + + xfer += oprot->writeFieldBegin("roleName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->roleName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principalName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->principalName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principalType", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32(static_cast(this->principalType)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("grantOption", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool(this->grantOption); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("grantTime", ::apache::thrift::protocol::T_I32, 5); + xfer += oprot->writeI32(this->grantTime); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("grantorName", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->grantorName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("grantorPrincipalType", ::apache::thrift::protocol::T_I32, 7); + xfer += oprot->writeI32(static_cast(this->grantorPrincipalType)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(RolePrincipalGrant &a, RolePrincipalGrant &b) noexcept { + using ::std::swap; + swap(a.roleName, b.roleName); + swap(a.principalName, b.principalName); + swap(a.principalType, b.principalType); + swap(a.grantOption, b.grantOption); + swap(a.grantTime, b.grantTime); + swap(a.grantorName, b.grantorName); + swap(a.grantorPrincipalType, b.grantorPrincipalType); + swap(a.__isset, b.__isset); +} + +bool RolePrincipalGrant::operator==(const RolePrincipalGrant & rhs) const +{ + if (!(roleName == rhs.roleName)) + return false; + if (!(principalName == rhs.principalName)) + return false; + if (!(principalType == rhs.principalType)) + return false; + if (!(grantOption == rhs.grantOption)) + return false; + if (!(grantTime == rhs.grantTime)) + return false; + if (!(grantorName == rhs.grantorName)) + return false; + if (!(grantorPrincipalType == rhs.grantorPrincipalType)) + return false; + return true; +} + +RolePrincipalGrant::RolePrincipalGrant(const RolePrincipalGrant& other194) { + roleName = other194.roleName; + principalName = other194.principalName; + principalType = other194.principalType; + grantOption = other194.grantOption; + grantTime = other194.grantTime; + grantorName = other194.grantorName; + grantorPrincipalType = other194.grantorPrincipalType; + __isset = other194.__isset; +} +RolePrincipalGrant& RolePrincipalGrant::operator=(const RolePrincipalGrant& other195) { + roleName = other195.roleName; + principalName = other195.principalName; + principalType = other195.principalType; + grantOption = other195.grantOption; + grantTime = other195.grantTime; + grantorName = other195.grantorName; + grantorPrincipalType = other195.grantorPrincipalType; + __isset = other195.__isset; + return *this; +} +void RolePrincipalGrant::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "RolePrincipalGrant("; + out << "roleName=" << to_string(roleName); + out << ", " << "principalName=" << to_string(principalName); + out << ", " << "principalType=" << to_string(principalType); + out << ", " << "grantOption=" << to_string(grantOption); + out << ", " << "grantTime=" << to_string(grantTime); + out << ", " << "grantorName=" << to_string(grantorName); + out << ", " << "grantorPrincipalType=" << to_string(grantorPrincipalType); + out << ")"; +} + + +GetRoleGrantsForPrincipalRequest::~GetRoleGrantsForPrincipalRequest() noexcept { +} + +GetRoleGrantsForPrincipalRequest::GetRoleGrantsForPrincipalRequest() noexcept + : principal_name(), + principal_type(static_cast(0)) { +} + +void GetRoleGrantsForPrincipalRequest::__set_principal_name(const std::string& val) { + this->principal_name = val; +} + +void GetRoleGrantsForPrincipalRequest::__set_principal_type(const PrincipalType::type val) { + this->principal_type = val; +} +std::ostream& operator<<(std::ostream& out, const GetRoleGrantsForPrincipalRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetRoleGrantsForPrincipalRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_principal_name = false; + bool isset_principal_type = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->principal_name); + isset_principal_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast196; + xfer += iprot->readI32(ecast196); + this->principal_type = static_cast(ecast196); + isset_principal_type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_principal_name) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_principal_type) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetRoleGrantsForPrincipalRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetRoleGrantsForPrincipalRequest"); + + xfer += oprot->writeFieldBegin("principal_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->principal_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(static_cast(this->principal_type)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetRoleGrantsForPrincipalRequest &a, GetRoleGrantsForPrincipalRequest &b) noexcept { + using ::std::swap; + swap(a.principal_name, b.principal_name); + swap(a.principal_type, b.principal_type); +} + +bool GetRoleGrantsForPrincipalRequest::operator==(const GetRoleGrantsForPrincipalRequest & rhs) const +{ + if (!(principal_name == rhs.principal_name)) + return false; + if (!(principal_type == rhs.principal_type)) + return false; + return true; +} + +GetRoleGrantsForPrincipalRequest::GetRoleGrantsForPrincipalRequest(const GetRoleGrantsForPrincipalRequest& other197) { + principal_name = other197.principal_name; + principal_type = other197.principal_type; +} +GetRoleGrantsForPrincipalRequest& GetRoleGrantsForPrincipalRequest::operator=(const GetRoleGrantsForPrincipalRequest& other198) { + principal_name = other198.principal_name; + principal_type = other198.principal_type; + return *this; +} +void GetRoleGrantsForPrincipalRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetRoleGrantsForPrincipalRequest("; + out << "principal_name=" << to_string(principal_name); + out << ", " << "principal_type=" << to_string(principal_type); + out << ")"; +} + + +GetRoleGrantsForPrincipalResponse::~GetRoleGrantsForPrincipalResponse() noexcept { +} + +GetRoleGrantsForPrincipalResponse::GetRoleGrantsForPrincipalResponse() noexcept { +} + +void GetRoleGrantsForPrincipalResponse::__set_principalGrants(const std::vector & val) { + this->principalGrants = val; +} +std::ostream& operator<<(std::ostream& out, const GetRoleGrantsForPrincipalResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetRoleGrantsForPrincipalResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_principalGrants = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->principalGrants.clear(); + uint32_t _size199; + ::apache::thrift::protocol::TType _etype202; + xfer += iprot->readListBegin(_etype202, _size199); + this->principalGrants.resize(_size199); + uint32_t _i203; + for (_i203 = 0; _i203 < _size199; ++_i203) + { + xfer += this->principalGrants[_i203].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_principalGrants = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_principalGrants) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetRoleGrantsForPrincipalResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetRoleGrantsForPrincipalResponse"); + + xfer += oprot->writeFieldBegin("principalGrants", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->principalGrants.size())); + std::vector ::const_iterator _iter204; + for (_iter204 = this->principalGrants.begin(); _iter204 != this->principalGrants.end(); ++_iter204) + { + xfer += (*_iter204).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetRoleGrantsForPrincipalResponse &a, GetRoleGrantsForPrincipalResponse &b) noexcept { + using ::std::swap; + swap(a.principalGrants, b.principalGrants); +} + +bool GetRoleGrantsForPrincipalResponse::operator==(const GetRoleGrantsForPrincipalResponse & rhs) const +{ + if (!(principalGrants == rhs.principalGrants)) + return false; + return true; +} + +GetRoleGrantsForPrincipalResponse::GetRoleGrantsForPrincipalResponse(const GetRoleGrantsForPrincipalResponse& other205) { + principalGrants = other205.principalGrants; +} +GetRoleGrantsForPrincipalResponse& GetRoleGrantsForPrincipalResponse::operator=(const GetRoleGrantsForPrincipalResponse& other206) { + principalGrants = other206.principalGrants; + return *this; +} +void GetRoleGrantsForPrincipalResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetRoleGrantsForPrincipalResponse("; + out << "principalGrants=" << to_string(principalGrants); + out << ")"; +} + + +GetPrincipalsInRoleRequest::~GetPrincipalsInRoleRequest() noexcept { +} + +GetPrincipalsInRoleRequest::GetPrincipalsInRoleRequest() noexcept + : roleName() { +} + +void GetPrincipalsInRoleRequest::__set_roleName(const std::string& val) { + this->roleName = val; +} +std::ostream& operator<<(std::ostream& out, const GetPrincipalsInRoleRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetPrincipalsInRoleRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_roleName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->roleName); + isset_roleName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_roleName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetPrincipalsInRoleRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetPrincipalsInRoleRequest"); + + xfer += oprot->writeFieldBegin("roleName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->roleName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetPrincipalsInRoleRequest &a, GetPrincipalsInRoleRequest &b) noexcept { + using ::std::swap; + swap(a.roleName, b.roleName); +} + +bool GetPrincipalsInRoleRequest::operator==(const GetPrincipalsInRoleRequest & rhs) const +{ + if (!(roleName == rhs.roleName)) + return false; + return true; +} + +GetPrincipalsInRoleRequest::GetPrincipalsInRoleRequest(const GetPrincipalsInRoleRequest& other207) { + roleName = other207.roleName; +} +GetPrincipalsInRoleRequest& GetPrincipalsInRoleRequest::operator=(const GetPrincipalsInRoleRequest& other208) { + roleName = other208.roleName; + return *this; +} +void GetPrincipalsInRoleRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetPrincipalsInRoleRequest("; + out << "roleName=" << to_string(roleName); + out << ")"; +} + + +GetPrincipalsInRoleResponse::~GetPrincipalsInRoleResponse() noexcept { +} + +GetPrincipalsInRoleResponse::GetPrincipalsInRoleResponse() noexcept { +} + +void GetPrincipalsInRoleResponse::__set_principalGrants(const std::vector & val) { + this->principalGrants = val; +} +std::ostream& operator<<(std::ostream& out, const GetPrincipalsInRoleResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetPrincipalsInRoleResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_principalGrants = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->principalGrants.clear(); + uint32_t _size209; + ::apache::thrift::protocol::TType _etype212; + xfer += iprot->readListBegin(_etype212, _size209); + this->principalGrants.resize(_size209); + uint32_t _i213; + for (_i213 = 0; _i213 < _size209; ++_i213) + { + xfer += this->principalGrants[_i213].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_principalGrants = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_principalGrants) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetPrincipalsInRoleResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetPrincipalsInRoleResponse"); + + xfer += oprot->writeFieldBegin("principalGrants", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->principalGrants.size())); + std::vector ::const_iterator _iter214; + for (_iter214 = this->principalGrants.begin(); _iter214 != this->principalGrants.end(); ++_iter214) + { + xfer += (*_iter214).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetPrincipalsInRoleResponse &a, GetPrincipalsInRoleResponse &b) noexcept { + using ::std::swap; + swap(a.principalGrants, b.principalGrants); +} + +bool GetPrincipalsInRoleResponse::operator==(const GetPrincipalsInRoleResponse & rhs) const +{ + if (!(principalGrants == rhs.principalGrants)) + return false; + return true; +} + +GetPrincipalsInRoleResponse::GetPrincipalsInRoleResponse(const GetPrincipalsInRoleResponse& other215) { + principalGrants = other215.principalGrants; +} +GetPrincipalsInRoleResponse& GetPrincipalsInRoleResponse::operator=(const GetPrincipalsInRoleResponse& other216) { + principalGrants = other216.principalGrants; + return *this; +} +void GetPrincipalsInRoleResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetPrincipalsInRoleResponse("; + out << "principalGrants=" << to_string(principalGrants); + out << ")"; +} + + +GrantRevokeRoleRequest::~GrantRevokeRoleRequest() noexcept { +} + +GrantRevokeRoleRequest::GrantRevokeRoleRequest() noexcept + : requestType(static_cast(0)), + roleName(), + principalName(), + principalType(static_cast(0)), + grantor(), + grantorType(static_cast(0)), + grantOption(0) { +} + +void GrantRevokeRoleRequest::__set_requestType(const GrantRevokeType::type val) { + this->requestType = val; +} + +void GrantRevokeRoleRequest::__set_roleName(const std::string& val) { + this->roleName = val; +} + +void GrantRevokeRoleRequest::__set_principalName(const std::string& val) { + this->principalName = val; +} + +void GrantRevokeRoleRequest::__set_principalType(const PrincipalType::type val) { + this->principalType = val; +} + +void GrantRevokeRoleRequest::__set_grantor(const std::string& val) { + this->grantor = val; +__isset.grantor = true; +} + +void GrantRevokeRoleRequest::__set_grantorType(const PrincipalType::type val) { + this->grantorType = val; +__isset.grantorType = true; +} + +void GrantRevokeRoleRequest::__set_grantOption(const bool val) { + this->grantOption = val; +__isset.grantOption = true; +} +std::ostream& operator<<(std::ostream& out, const GrantRevokeRoleRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GrantRevokeRoleRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast217; + xfer += iprot->readI32(ecast217); + this->requestType = static_cast(ecast217); + this->__isset.requestType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->roleName); + this->__isset.roleName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->principalName); + this->__isset.principalName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast218; + xfer += iprot->readI32(ecast218); + this->principalType = static_cast(ecast218); + this->__isset.principalType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->grantor); + this->__isset.grantor = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast219; + xfer += iprot->readI32(ecast219); + this->grantorType = static_cast(ecast219); + this->__isset.grantorType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->grantOption); + this->__isset.grantOption = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t GrantRevokeRoleRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GrantRevokeRoleRequest"); + + xfer += oprot->writeFieldBegin("requestType", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32(static_cast(this->requestType)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("roleName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->roleName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principalName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->principalName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principalType", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32(static_cast(this->principalType)); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.grantor) { + xfer += oprot->writeFieldBegin("grantor", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->grantor); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.grantorType) { + xfer += oprot->writeFieldBegin("grantorType", ::apache::thrift::protocol::T_I32, 6); + xfer += oprot->writeI32(static_cast(this->grantorType)); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.grantOption) { + xfer += oprot->writeFieldBegin("grantOption", ::apache::thrift::protocol::T_BOOL, 7); + xfer += oprot->writeBool(this->grantOption); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GrantRevokeRoleRequest &a, GrantRevokeRoleRequest &b) noexcept { + using ::std::swap; + swap(a.requestType, b.requestType); + swap(a.roleName, b.roleName); + swap(a.principalName, b.principalName); + swap(a.principalType, b.principalType); + swap(a.grantor, b.grantor); + swap(a.grantorType, b.grantorType); + swap(a.grantOption, b.grantOption); + swap(a.__isset, b.__isset); +} + +bool GrantRevokeRoleRequest::operator==(const GrantRevokeRoleRequest & rhs) const +{ + if (!(requestType == rhs.requestType)) + return false; + if (!(roleName == rhs.roleName)) + return false; + if (!(principalName == rhs.principalName)) + return false; + if (!(principalType == rhs.principalType)) + return false; + if (__isset.grantor != rhs.__isset.grantor) + return false; + else if (__isset.grantor && !(grantor == rhs.grantor)) + return false; + if (__isset.grantorType != rhs.__isset.grantorType) + return false; + else if (__isset.grantorType && !(grantorType == rhs.grantorType)) + return false; + if (__isset.grantOption != rhs.__isset.grantOption) + return false; + else if (__isset.grantOption && !(grantOption == rhs.grantOption)) + return false; + return true; +} + +GrantRevokeRoleRequest::GrantRevokeRoleRequest(const GrantRevokeRoleRequest& other220) { + requestType = other220.requestType; + roleName = other220.roleName; + principalName = other220.principalName; + principalType = other220.principalType; + grantor = other220.grantor; + grantorType = other220.grantorType; + grantOption = other220.grantOption; + __isset = other220.__isset; +} +GrantRevokeRoleRequest& GrantRevokeRoleRequest::operator=(const GrantRevokeRoleRequest& other221) { + requestType = other221.requestType; + roleName = other221.roleName; + principalName = other221.principalName; + principalType = other221.principalType; + grantor = other221.grantor; + grantorType = other221.grantorType; + grantOption = other221.grantOption; + __isset = other221.__isset; + return *this; +} +void GrantRevokeRoleRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GrantRevokeRoleRequest("; + out << "requestType=" << to_string(requestType); + out << ", " << "roleName=" << to_string(roleName); + out << ", " << "principalName=" << to_string(principalName); + out << ", " << "principalType=" << to_string(principalType); + out << ", " << "grantor="; (__isset.grantor ? (out << to_string(grantor)) : (out << "")); + out << ", " << "grantorType="; (__isset.grantorType ? (out << to_string(grantorType)) : (out << "")); + out << ", " << "grantOption="; (__isset.grantOption ? (out << to_string(grantOption)) : (out << "")); + out << ")"; +} + + +GrantRevokeRoleResponse::~GrantRevokeRoleResponse() noexcept { +} + +GrantRevokeRoleResponse::GrantRevokeRoleResponse() noexcept + : success(0) { +} + +void GrantRevokeRoleResponse::__set_success(const bool val) { + this->success = val; +__isset.success = true; +} +std::ostream& operator<<(std::ostream& out, const GrantRevokeRoleResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GrantRevokeRoleResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t GrantRevokeRoleResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GrantRevokeRoleResponse"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 1); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GrantRevokeRoleResponse &a, GrantRevokeRoleResponse &b) noexcept { + using ::std::swap; + swap(a.success, b.success); + swap(a.__isset, b.__isset); +} + +bool GrantRevokeRoleResponse::operator==(const GrantRevokeRoleResponse & rhs) const +{ + if (__isset.success != rhs.__isset.success) + return false; + else if (__isset.success && !(success == rhs.success)) + return false; + return true; +} + +GrantRevokeRoleResponse::GrantRevokeRoleResponse(const GrantRevokeRoleResponse& other222) noexcept { + success = other222.success; + __isset = other222.__isset; +} +GrantRevokeRoleResponse& GrantRevokeRoleResponse::operator=(const GrantRevokeRoleResponse& other223) noexcept { + success = other223.success; + __isset = other223.__isset; + return *this; +} +void GrantRevokeRoleResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GrantRevokeRoleResponse("; + out << "success="; (__isset.success ? (out << to_string(success)) : (out << "")); + out << ")"; +} + + +Catalog::~Catalog() noexcept { +} + +Catalog::Catalog() noexcept + : name(), + description(), + locationUri(), + createTime(0) { +} + +void Catalog::__set_name(const std::string& val) { + this->name = val; +} + +void Catalog::__set_description(const std::string& val) { + this->description = val; +__isset.description = true; +} + +void Catalog::__set_locationUri(const std::string& val) { + this->locationUri = val; +} + +void Catalog::__set_createTime(const int32_t val) { + this->createTime = val; +__isset.createTime = true; +} +std::ostream& operator<<(std::ostream& out, const Catalog& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Catalog::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->description); + this->__isset.description = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->locationUri); + this->__isset.locationUri = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->createTime); + this->__isset.createTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Catalog::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Catalog"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.description) { + xfer += oprot->writeFieldBegin("description", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->description); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("locationUri", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->locationUri); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.createTime) { + xfer += oprot->writeFieldBegin("createTime", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32(this->createTime); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Catalog &a, Catalog &b) noexcept { + using ::std::swap; + swap(a.name, b.name); + swap(a.description, b.description); + swap(a.locationUri, b.locationUri); + swap(a.createTime, b.createTime); + swap(a.__isset, b.__isset); +} + +bool Catalog::operator==(const Catalog & rhs) const +{ + if (!(name == rhs.name)) + return false; + if (__isset.description != rhs.__isset.description) + return false; + else if (__isset.description && !(description == rhs.description)) + return false; + if (!(locationUri == rhs.locationUri)) + return false; + if (__isset.createTime != rhs.__isset.createTime) + return false; + else if (__isset.createTime && !(createTime == rhs.createTime)) + return false; + return true; +} + +Catalog::Catalog(const Catalog& other224) { + name = other224.name; + description = other224.description; + locationUri = other224.locationUri; + createTime = other224.createTime; + __isset = other224.__isset; +} +Catalog& Catalog::operator=(const Catalog& other225) { + name = other225.name; + description = other225.description; + locationUri = other225.locationUri; + createTime = other225.createTime; + __isset = other225.__isset; + return *this; +} +void Catalog::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Catalog("; + out << "name=" << to_string(name); + out << ", " << "description="; (__isset.description ? (out << to_string(description)) : (out << "")); + out << ", " << "locationUri=" << to_string(locationUri); + out << ", " << "createTime="; (__isset.createTime ? (out << to_string(createTime)) : (out << "")); + out << ")"; +} + + +CreateCatalogRequest::~CreateCatalogRequest() noexcept { +} + +CreateCatalogRequest::CreateCatalogRequest() noexcept { +} + +void CreateCatalogRequest::__set_catalog(const Catalog& val) { + this->catalog = val; +} +std::ostream& operator<<(std::ostream& out, const CreateCatalogRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t CreateCatalogRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->catalog.read(iprot); + this->__isset.catalog = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t CreateCatalogRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CreateCatalogRequest"); + + xfer += oprot->writeFieldBegin("catalog", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->catalog.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CreateCatalogRequest &a, CreateCatalogRequest &b) noexcept { + using ::std::swap; + swap(a.catalog, b.catalog); + swap(a.__isset, b.__isset); +} + +bool CreateCatalogRequest::operator==(const CreateCatalogRequest & rhs) const +{ + if (!(catalog == rhs.catalog)) + return false; + return true; +} + +CreateCatalogRequest::CreateCatalogRequest(const CreateCatalogRequest& other226) { + catalog = other226.catalog; + __isset = other226.__isset; +} +CreateCatalogRequest& CreateCatalogRequest::operator=(const CreateCatalogRequest& other227) { + catalog = other227.catalog; + __isset = other227.__isset; + return *this; +} +void CreateCatalogRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CreateCatalogRequest("; + out << "catalog=" << to_string(catalog); + out << ")"; +} + + +AlterCatalogRequest::~AlterCatalogRequest() noexcept { +} + +AlterCatalogRequest::AlterCatalogRequest() noexcept + : name() { +} + +void AlterCatalogRequest::__set_name(const std::string& val) { + this->name = val; +} + +void AlterCatalogRequest::__set_newCat(const Catalog& val) { + this->newCat = val; +} +std::ostream& operator<<(std::ostream& out, const AlterCatalogRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AlterCatalogRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->newCat.read(iprot); + this->__isset.newCat = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t AlterCatalogRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AlterCatalogRequest"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("newCat", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->newCat.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AlterCatalogRequest &a, AlterCatalogRequest &b) noexcept { + using ::std::swap; + swap(a.name, b.name); + swap(a.newCat, b.newCat); + swap(a.__isset, b.__isset); +} + +bool AlterCatalogRequest::operator==(const AlterCatalogRequest & rhs) const +{ + if (!(name == rhs.name)) + return false; + if (!(newCat == rhs.newCat)) + return false; + return true; +} + +AlterCatalogRequest::AlterCatalogRequest(const AlterCatalogRequest& other228) { + name = other228.name; + newCat = other228.newCat; + __isset = other228.__isset; +} +AlterCatalogRequest& AlterCatalogRequest::operator=(const AlterCatalogRequest& other229) { + name = other229.name; + newCat = other229.newCat; + __isset = other229.__isset; + return *this; +} +void AlterCatalogRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AlterCatalogRequest("; + out << "name=" << to_string(name); + out << ", " << "newCat=" << to_string(newCat); + out << ")"; +} + + +GetCatalogRequest::~GetCatalogRequest() noexcept { +} + +GetCatalogRequest::GetCatalogRequest() noexcept + : name() { +} + +void GetCatalogRequest::__set_name(const std::string& val) { + this->name = val; +} +std::ostream& operator<<(std::ostream& out, const GetCatalogRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetCatalogRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t GetCatalogRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetCatalogRequest"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetCatalogRequest &a, GetCatalogRequest &b) noexcept { + using ::std::swap; + swap(a.name, b.name); + swap(a.__isset, b.__isset); +} + +bool GetCatalogRequest::operator==(const GetCatalogRequest & rhs) const +{ + if (!(name == rhs.name)) + return false; + return true; +} + +GetCatalogRequest::GetCatalogRequest(const GetCatalogRequest& other230) { + name = other230.name; + __isset = other230.__isset; +} +GetCatalogRequest& GetCatalogRequest::operator=(const GetCatalogRequest& other231) { + name = other231.name; + __isset = other231.__isset; + return *this; +} +void GetCatalogRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetCatalogRequest("; + out << "name=" << to_string(name); + out << ")"; +} + + +GetCatalogResponse::~GetCatalogResponse() noexcept { +} + +GetCatalogResponse::GetCatalogResponse() noexcept { +} + +void GetCatalogResponse::__set_catalog(const Catalog& val) { + this->catalog = val; +} +std::ostream& operator<<(std::ostream& out, const GetCatalogResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetCatalogResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->catalog.read(iprot); + this->__isset.catalog = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t GetCatalogResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetCatalogResponse"); + + xfer += oprot->writeFieldBegin("catalog", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->catalog.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetCatalogResponse &a, GetCatalogResponse &b) noexcept { + using ::std::swap; + swap(a.catalog, b.catalog); + swap(a.__isset, b.__isset); +} + +bool GetCatalogResponse::operator==(const GetCatalogResponse & rhs) const +{ + if (!(catalog == rhs.catalog)) + return false; + return true; +} + +GetCatalogResponse::GetCatalogResponse(const GetCatalogResponse& other232) { + catalog = other232.catalog; + __isset = other232.__isset; +} +GetCatalogResponse& GetCatalogResponse::operator=(const GetCatalogResponse& other233) { + catalog = other233.catalog; + __isset = other233.__isset; + return *this; +} +void GetCatalogResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetCatalogResponse("; + out << "catalog=" << to_string(catalog); + out << ")"; +} + + +GetCatalogsResponse::~GetCatalogsResponse() noexcept { +} + +GetCatalogsResponse::GetCatalogsResponse() noexcept { +} + +void GetCatalogsResponse::__set_names(const std::vector & val) { + this->names = val; +} +std::ostream& operator<<(std::ostream& out, const GetCatalogsResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetCatalogsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->names.clear(); + uint32_t _size234; + ::apache::thrift::protocol::TType _etype237; + xfer += iprot->readListBegin(_etype237, _size234); + this->names.resize(_size234); + uint32_t _i238; + for (_i238 = 0; _i238 < _size234; ++_i238) + { + xfer += iprot->readString(this->names[_i238]); + } + xfer += iprot->readListEnd(); + } + this->__isset.names = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t GetCatalogsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetCatalogsResponse"); + + xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->names.size())); + std::vector ::const_iterator _iter239; + for (_iter239 = this->names.begin(); _iter239 != this->names.end(); ++_iter239) + { + xfer += oprot->writeString((*_iter239)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetCatalogsResponse &a, GetCatalogsResponse &b) noexcept { + using ::std::swap; + swap(a.names, b.names); + swap(a.__isset, b.__isset); +} + +bool GetCatalogsResponse::operator==(const GetCatalogsResponse & rhs) const +{ + if (!(names == rhs.names)) + return false; + return true; +} + +GetCatalogsResponse::GetCatalogsResponse(const GetCatalogsResponse& other240) { + names = other240.names; + __isset = other240.__isset; +} +GetCatalogsResponse& GetCatalogsResponse::operator=(const GetCatalogsResponse& other241) { + names = other241.names; + __isset = other241.__isset; + return *this; +} +void GetCatalogsResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetCatalogsResponse("; + out << "names=" << to_string(names); + out << ")"; +} + + +DropCatalogRequest::~DropCatalogRequest() noexcept { +} + +DropCatalogRequest::DropCatalogRequest() noexcept + : name() { +} + +void DropCatalogRequest::__set_name(const std::string& val) { + this->name = val; +} +std::ostream& operator<<(std::ostream& out, const DropCatalogRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t DropCatalogRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t DropCatalogRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("DropCatalogRequest"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(DropCatalogRequest &a, DropCatalogRequest &b) noexcept { + using ::std::swap; + swap(a.name, b.name); + swap(a.__isset, b.__isset); +} + +bool DropCatalogRequest::operator==(const DropCatalogRequest & rhs) const +{ + if (!(name == rhs.name)) + return false; + return true; +} + +DropCatalogRequest::DropCatalogRequest(const DropCatalogRequest& other242) { + name = other242.name; + __isset = other242.__isset; +} +DropCatalogRequest& DropCatalogRequest::operator=(const DropCatalogRequest& other243) { + name = other243.name; + __isset = other243.__isset; + return *this; +} +void DropCatalogRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "DropCatalogRequest("; + out << "name=" << to_string(name); + out << ")"; +} + + +Database::~Database() noexcept { +} + +Database::Database() noexcept + : name(), + description(), + locationUri(), + ownerName(), + ownerType(static_cast(0)), + catalogName(), + createTime(0), + managedLocationUri(), + type(static_cast(0)), + connector_name(), + remote_dbname() { +} + +void Database::__set_name(const std::string& val) { + this->name = val; +} + +void Database::__set_description(const std::string& val) { + this->description = val; +} + +void Database::__set_locationUri(const std::string& val) { + this->locationUri = val; +} + +void Database::__set_parameters(const std::map & val) { + this->parameters = val; +} + +void Database::__set_privileges(const PrincipalPrivilegeSet& val) { + this->privileges = val; +__isset.privileges = true; +} + +void Database::__set_ownerName(const std::string& val) { + this->ownerName = val; +__isset.ownerName = true; +} + +void Database::__set_ownerType(const PrincipalType::type val) { + this->ownerType = val; +__isset.ownerType = true; +} + +void Database::__set_catalogName(const std::string& val) { + this->catalogName = val; +__isset.catalogName = true; +} + +void Database::__set_createTime(const int32_t val) { + this->createTime = val; +__isset.createTime = true; +} + +void Database::__set_managedLocationUri(const std::string& val) { + this->managedLocationUri = val; +__isset.managedLocationUri = true; +} + +void Database::__set_type(const DatabaseType::type val) { + this->type = val; +__isset.type = true; +} + +void Database::__set_connector_name(const std::string& val) { + this->connector_name = val; +__isset.connector_name = true; +} + +void Database::__set_remote_dbname(const std::string& val) { + this->remote_dbname = val; +__isset.remote_dbname = true; +} +std::ostream& operator<<(std::ostream& out, const Database& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Database::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->description); + this->__isset.description = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->locationUri); + this->__isset.locationUri = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->parameters.clear(); + uint32_t _size244; + ::apache::thrift::protocol::TType _ktype245; + ::apache::thrift::protocol::TType _vtype246; + xfer += iprot->readMapBegin(_ktype245, _vtype246, _size244); + uint32_t _i248; + for (_i248 = 0; _i248 < _size244; ++_i248) + { + std::string _key249; + xfer += iprot->readString(_key249); + std::string& _val250 = this->parameters[_key249]; + xfer += iprot->readString(_val250); + } + xfer += iprot->readMapEnd(); + } + this->__isset.parameters = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->privileges.read(iprot); + this->__isset.privileges = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ownerName); + this->__isset.ownerName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast251; + xfer += iprot->readI32(ecast251); + this->ownerType = static_cast(ecast251); + this->__isset.ownerType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catalogName); + this->__isset.catalogName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->createTime); + this->__isset.createTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->managedLocationUri); + this->__isset.managedLocationUri = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 11: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast252; + xfer += iprot->readI32(ecast252); + this->type = static_cast(ecast252); + this->__isset.type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 12: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->connector_name); + this->__isset.connector_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 13: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->remote_dbname); + this->__isset.remote_dbname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Database::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Database"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("description", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->description); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("locationUri", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->locationUri); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 4); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); + std::map ::const_iterator _iter253; + for (_iter253 = this->parameters.begin(); _iter253 != this->parameters.end(); ++_iter253) + { + xfer += oprot->writeString(_iter253->first); + xfer += oprot->writeString(_iter253->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.privileges) { + xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_STRUCT, 5); + xfer += this->privileges.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ownerName) { + xfer += oprot->writeFieldBegin("ownerName", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->ownerName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ownerType) { + xfer += oprot->writeFieldBegin("ownerType", ::apache::thrift::protocol::T_I32, 7); + xfer += oprot->writeI32(static_cast(this->ownerType)); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.catalogName) { + xfer += oprot->writeFieldBegin("catalogName", ::apache::thrift::protocol::T_STRING, 8); + xfer += oprot->writeString(this->catalogName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.createTime) { + xfer += oprot->writeFieldBegin("createTime", ::apache::thrift::protocol::T_I32, 9); + xfer += oprot->writeI32(this->createTime); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.managedLocationUri) { + xfer += oprot->writeFieldBegin("managedLocationUri", ::apache::thrift::protocol::T_STRING, 10); + xfer += oprot->writeString(this->managedLocationUri); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.type) { + xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 11); + xfer += oprot->writeI32(static_cast(this->type)); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.connector_name) { + xfer += oprot->writeFieldBegin("connector_name", ::apache::thrift::protocol::T_STRING, 12); + xfer += oprot->writeString(this->connector_name); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.remote_dbname) { + xfer += oprot->writeFieldBegin("remote_dbname", ::apache::thrift::protocol::T_STRING, 13); + xfer += oprot->writeString(this->remote_dbname); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Database &a, Database &b) noexcept { + using ::std::swap; + swap(a.name, b.name); + swap(a.description, b.description); + swap(a.locationUri, b.locationUri); + swap(a.parameters, b.parameters); + swap(a.privileges, b.privileges); + swap(a.ownerName, b.ownerName); + swap(a.ownerType, b.ownerType); + swap(a.catalogName, b.catalogName); + swap(a.createTime, b.createTime); + swap(a.managedLocationUri, b.managedLocationUri); + swap(a.type, b.type); + swap(a.connector_name, b.connector_name); + swap(a.remote_dbname, b.remote_dbname); + swap(a.__isset, b.__isset); +} + +bool Database::operator==(const Database & rhs) const +{ + if (!(name == rhs.name)) + return false; + if (!(description == rhs.description)) + return false; + if (!(locationUri == rhs.locationUri)) + return false; + if (!(parameters == rhs.parameters)) + return false; + if (__isset.privileges != rhs.__isset.privileges) + return false; + else if (__isset.privileges && !(privileges == rhs.privileges)) + return false; + if (__isset.ownerName != rhs.__isset.ownerName) + return false; + else if (__isset.ownerName && !(ownerName == rhs.ownerName)) + return false; + if (__isset.ownerType != rhs.__isset.ownerType) + return false; + else if (__isset.ownerType && !(ownerType == rhs.ownerType)) + return false; + if (__isset.catalogName != rhs.__isset.catalogName) + return false; + else if (__isset.catalogName && !(catalogName == rhs.catalogName)) + return false; + if (__isset.createTime != rhs.__isset.createTime) + return false; + else if (__isset.createTime && !(createTime == rhs.createTime)) + return false; + if (__isset.managedLocationUri != rhs.__isset.managedLocationUri) + return false; + else if (__isset.managedLocationUri && !(managedLocationUri == rhs.managedLocationUri)) + return false; + if (__isset.type != rhs.__isset.type) + return false; + else if (__isset.type && !(type == rhs.type)) + return false; + if (__isset.connector_name != rhs.__isset.connector_name) + return false; + else if (__isset.connector_name && !(connector_name == rhs.connector_name)) + return false; + if (__isset.remote_dbname != rhs.__isset.remote_dbname) + return false; + else if (__isset.remote_dbname && !(remote_dbname == rhs.remote_dbname)) + return false; + return true; +} + +Database::Database(const Database& other254) { + name = other254.name; + description = other254.description; + locationUri = other254.locationUri; + parameters = other254.parameters; + privileges = other254.privileges; + ownerName = other254.ownerName; + ownerType = other254.ownerType; + catalogName = other254.catalogName; + createTime = other254.createTime; + managedLocationUri = other254.managedLocationUri; + type = other254.type; + connector_name = other254.connector_name; + remote_dbname = other254.remote_dbname; + __isset = other254.__isset; +} +Database& Database::operator=(const Database& other255) { + name = other255.name; + description = other255.description; + locationUri = other255.locationUri; + parameters = other255.parameters; + privileges = other255.privileges; + ownerName = other255.ownerName; + ownerType = other255.ownerType; + catalogName = other255.catalogName; + createTime = other255.createTime; + managedLocationUri = other255.managedLocationUri; + type = other255.type; + connector_name = other255.connector_name; + remote_dbname = other255.remote_dbname; + __isset = other255.__isset; + return *this; +} +void Database::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Database("; + out << "name=" << to_string(name); + out << ", " << "description=" << to_string(description); + out << ", " << "locationUri=" << to_string(locationUri); + out << ", " << "parameters=" << to_string(parameters); + out << ", " << "privileges="; (__isset.privileges ? (out << to_string(privileges)) : (out << "")); + out << ", " << "ownerName="; (__isset.ownerName ? (out << to_string(ownerName)) : (out << "")); + out << ", " << "ownerType="; (__isset.ownerType ? (out << to_string(ownerType)) : (out << "")); + out << ", " << "catalogName="; (__isset.catalogName ? (out << to_string(catalogName)) : (out << "")); + out << ", " << "createTime="; (__isset.createTime ? (out << to_string(createTime)) : (out << "")); + out << ", " << "managedLocationUri="; (__isset.managedLocationUri ? (out << to_string(managedLocationUri)) : (out << "")); + out << ", " << "type="; (__isset.type ? (out << to_string(type)) : (out << "")); + out << ", " << "connector_name="; (__isset.connector_name ? (out << to_string(connector_name)) : (out << "")); + out << ", " << "remote_dbname="; (__isset.remote_dbname ? (out << to_string(remote_dbname)) : (out << "")); + out << ")"; +} + + +SerDeInfo::~SerDeInfo() noexcept { +} + +SerDeInfo::SerDeInfo() noexcept + : name(), + serializationLib(), + description(), + serializerClass(), + deserializerClass(), + serdeType(static_cast(0)) { +} + +void SerDeInfo::__set_name(const std::string& val) { + this->name = val; +} + +void SerDeInfo::__set_serializationLib(const std::string& val) { + this->serializationLib = val; +} + +void SerDeInfo::__set_parameters(const std::map & val) { + this->parameters = val; +} + +void SerDeInfo::__set_description(const std::string& val) { + this->description = val; +__isset.description = true; +} + +void SerDeInfo::__set_serializerClass(const std::string& val) { + this->serializerClass = val; +__isset.serializerClass = true; +} + +void SerDeInfo::__set_deserializerClass(const std::string& val) { + this->deserializerClass = val; +__isset.deserializerClass = true; +} + +void SerDeInfo::__set_serdeType(const SerdeType::type val) { + this->serdeType = val; +__isset.serdeType = true; +} +std::ostream& operator<<(std::ostream& out, const SerDeInfo& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t SerDeInfo::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->serializationLib); + this->__isset.serializationLib = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->parameters.clear(); + uint32_t _size256; + ::apache::thrift::protocol::TType _ktype257; + ::apache::thrift::protocol::TType _vtype258; + xfer += iprot->readMapBegin(_ktype257, _vtype258, _size256); + uint32_t _i260; + for (_i260 = 0; _i260 < _size256; ++_i260) + { + std::string _key261; + xfer += iprot->readString(_key261); + std::string& _val262 = this->parameters[_key261]; + xfer += iprot->readString(_val262); + } + xfer += iprot->readMapEnd(); + } + this->__isset.parameters = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->description); + this->__isset.description = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->serializerClass); + this->__isset.serializerClass = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->deserializerClass); + this->__isset.deserializerClass = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast263; + xfer += iprot->readI32(ecast263); + this->serdeType = static_cast(ecast263); + this->__isset.serdeType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t SerDeInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("SerDeInfo"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("serializationLib", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->serializationLib); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 3); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); + std::map ::const_iterator _iter264; + for (_iter264 = this->parameters.begin(); _iter264 != this->parameters.end(); ++_iter264) + { + xfer += oprot->writeString(_iter264->first); + xfer += oprot->writeString(_iter264->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.description) { + xfer += oprot->writeFieldBegin("description", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->description); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.serializerClass) { + xfer += oprot->writeFieldBegin("serializerClass", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->serializerClass); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.deserializerClass) { + xfer += oprot->writeFieldBegin("deserializerClass", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->deserializerClass); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.serdeType) { + xfer += oprot->writeFieldBegin("serdeType", ::apache::thrift::protocol::T_I32, 7); + xfer += oprot->writeI32(static_cast(this->serdeType)); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(SerDeInfo &a, SerDeInfo &b) noexcept { + using ::std::swap; + swap(a.name, b.name); + swap(a.serializationLib, b.serializationLib); + swap(a.parameters, b.parameters); + swap(a.description, b.description); + swap(a.serializerClass, b.serializerClass); + swap(a.deserializerClass, b.deserializerClass); + swap(a.serdeType, b.serdeType); + swap(a.__isset, b.__isset); +} + +bool SerDeInfo::operator==(const SerDeInfo & rhs) const +{ + if (!(name == rhs.name)) + return false; + if (!(serializationLib == rhs.serializationLib)) + return false; + if (!(parameters == rhs.parameters)) + return false; + if (__isset.description != rhs.__isset.description) + return false; + else if (__isset.description && !(description == rhs.description)) + return false; + if (__isset.serializerClass != rhs.__isset.serializerClass) + return false; + else if (__isset.serializerClass && !(serializerClass == rhs.serializerClass)) + return false; + if (__isset.deserializerClass != rhs.__isset.deserializerClass) + return false; + else if (__isset.deserializerClass && !(deserializerClass == rhs.deserializerClass)) + return false; + if (__isset.serdeType != rhs.__isset.serdeType) + return false; + else if (__isset.serdeType && !(serdeType == rhs.serdeType)) + return false; + return true; +} + +SerDeInfo::SerDeInfo(const SerDeInfo& other265) { + name = other265.name; + serializationLib = other265.serializationLib; + parameters = other265.parameters; + description = other265.description; + serializerClass = other265.serializerClass; + deserializerClass = other265.deserializerClass; + serdeType = other265.serdeType; + __isset = other265.__isset; +} +SerDeInfo& SerDeInfo::operator=(const SerDeInfo& other266) { + name = other266.name; + serializationLib = other266.serializationLib; + parameters = other266.parameters; + description = other266.description; + serializerClass = other266.serializerClass; + deserializerClass = other266.deserializerClass; + serdeType = other266.serdeType; + __isset = other266.__isset; + return *this; +} +void SerDeInfo::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "SerDeInfo("; + out << "name=" << to_string(name); + out << ", " << "serializationLib=" << to_string(serializationLib); + out << ", " << "parameters=" << to_string(parameters); + out << ", " << "description="; (__isset.description ? (out << to_string(description)) : (out << "")); + out << ", " << "serializerClass="; (__isset.serializerClass ? (out << to_string(serializerClass)) : (out << "")); + out << ", " << "deserializerClass="; (__isset.deserializerClass ? (out << to_string(deserializerClass)) : (out << "")); + out << ", " << "serdeType="; (__isset.serdeType ? (out << to_string(serdeType)) : (out << "")); + out << ")"; +} + + +Order::~Order() noexcept { +} + +Order::Order() noexcept + : col(), + order(0) { +} + +void Order::__set_col(const std::string& val) { + this->col = val; +} + +void Order::__set_order(const int32_t val) { + this->order = val; +} +std::ostream& operator<<(std::ostream& out, const Order& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Order::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->col); + this->__isset.col = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->order); + this->__isset.order = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Order::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Order"); + + xfer += oprot->writeFieldBegin("col", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->col); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("order", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(this->order); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Order &a, Order &b) noexcept { + using ::std::swap; + swap(a.col, b.col); + swap(a.order, b.order); + swap(a.__isset, b.__isset); +} + +bool Order::operator==(const Order & rhs) const +{ + if (!(col == rhs.col)) + return false; + if (!(order == rhs.order)) + return false; + return true; +} + +Order::Order(const Order& other267) { + col = other267.col; + order = other267.order; + __isset = other267.__isset; +} +Order& Order::operator=(const Order& other268) { + col = other268.col; + order = other268.order; + __isset = other268.__isset; + return *this; +} +void Order::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Order("; + out << "col=" << to_string(col); + out << ", " << "order=" << to_string(order); + out << ")"; +} + + +SkewedInfo::~SkewedInfo() noexcept { +} + +SkewedInfo::SkewedInfo() noexcept { +} + +void SkewedInfo::__set_skewedColNames(const std::vector & val) { + this->skewedColNames = val; +} + +void SkewedInfo::__set_skewedColValues(const std::vector > & val) { + this->skewedColValues = val; +} + +void SkewedInfo::__set_skewedColValueLocationMaps(const std::map , std::string> & val) { + this->skewedColValueLocationMaps = val; +} +std::ostream& operator<<(std::ostream& out, const SkewedInfo& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->skewedColNames.clear(); + uint32_t _size269; + ::apache::thrift::protocol::TType _etype272; + xfer += iprot->readListBegin(_etype272, _size269); + this->skewedColNames.resize(_size269); + uint32_t _i273; + for (_i273 = 0; _i273 < _size269; ++_i273) + { + xfer += iprot->readString(this->skewedColNames[_i273]); + } + xfer += iprot->readListEnd(); + } + this->__isset.skewedColNames = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->skewedColValues.clear(); + uint32_t _size274; + ::apache::thrift::protocol::TType _etype277; + xfer += iprot->readListBegin(_etype277, _size274); + this->skewedColValues.resize(_size274); + uint32_t _i278; + for (_i278 = 0; _i278 < _size274; ++_i278) + { + { + this->skewedColValues[_i278].clear(); + uint32_t _size279; + ::apache::thrift::protocol::TType _etype282; + xfer += iprot->readListBegin(_etype282, _size279); + this->skewedColValues[_i278].resize(_size279); + uint32_t _i283; + for (_i283 = 0; _i283 < _size279; ++_i283) + { + xfer += iprot->readString(this->skewedColValues[_i278][_i283]); + } + xfer += iprot->readListEnd(); + } + } + xfer += iprot->readListEnd(); + } + this->__isset.skewedColValues = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->skewedColValueLocationMaps.clear(); + uint32_t _size284; + ::apache::thrift::protocol::TType _ktype285; + ::apache::thrift::protocol::TType _vtype286; + xfer += iprot->readMapBegin(_ktype285, _vtype286, _size284); + uint32_t _i288; + for (_i288 = 0; _i288 < _size284; ++_i288) + { + std::vector _key289; + { + _key289.clear(); + uint32_t _size291; + ::apache::thrift::protocol::TType _etype294; + xfer += iprot->readListBegin(_etype294, _size291); + _key289.resize(_size291); + uint32_t _i295; + for (_i295 = 0; _i295 < _size291; ++_i295) + { + xfer += iprot->readString(_key289[_i295]); + } + xfer += iprot->readListEnd(); + } + std::string& _val290 = this->skewedColValueLocationMaps[_key289]; + xfer += iprot->readString(_val290); + } + xfer += iprot->readMapEnd(); + } + this->__isset.skewedColValueLocationMaps = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t SkewedInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("SkewedInfo"); + + xfer += oprot->writeFieldBegin("skewedColNames", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->skewedColNames.size())); + std::vector ::const_iterator _iter296; + for (_iter296 = this->skewedColNames.begin(); _iter296 != this->skewedColNames.end(); ++_iter296) + { + xfer += oprot->writeString((*_iter296)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("skewedColValues", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_LIST, static_cast(this->skewedColValues.size())); + std::vector > ::const_iterator _iter297; + for (_iter297 = this->skewedColValues.begin(); _iter297 != this->skewedColValues.end(); ++_iter297) + { + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*_iter297).size())); + std::vector ::const_iterator _iter298; + for (_iter298 = (*_iter297).begin(); _iter298 != (*_iter297).end(); ++_iter298) + { + xfer += oprot->writeString((*_iter298)); + } + xfer += oprot->writeListEnd(); + } + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("skewedColValueLocationMaps", ::apache::thrift::protocol::T_MAP, 3); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_LIST, ::apache::thrift::protocol::T_STRING, static_cast(this->skewedColValueLocationMaps.size())); + std::map , std::string> ::const_iterator _iter299; + for (_iter299 = this->skewedColValueLocationMaps.begin(); _iter299 != this->skewedColValueLocationMaps.end(); ++_iter299) + { + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(_iter299->first.size())); + std::vector ::const_iterator _iter300; + for (_iter300 = _iter299->first.begin(); _iter300 != _iter299->first.end(); ++_iter300) + { + xfer += oprot->writeString((*_iter300)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeString(_iter299->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(SkewedInfo &a, SkewedInfo &b) noexcept { + using ::std::swap; + swap(a.skewedColNames, b.skewedColNames); + swap(a.skewedColValues, b.skewedColValues); + swap(a.skewedColValueLocationMaps, b.skewedColValueLocationMaps); + swap(a.__isset, b.__isset); +} + +bool SkewedInfo::operator==(const SkewedInfo & rhs) const +{ + if (!(skewedColNames == rhs.skewedColNames)) + return false; + if (!(skewedColValues == rhs.skewedColValues)) + return false; + if (!(skewedColValueLocationMaps == rhs.skewedColValueLocationMaps)) + return false; + return true; +} + +SkewedInfo::SkewedInfo(const SkewedInfo& other301) { + skewedColNames = other301.skewedColNames; + skewedColValues = other301.skewedColValues; + skewedColValueLocationMaps = other301.skewedColValueLocationMaps; + __isset = other301.__isset; +} +SkewedInfo& SkewedInfo::operator=(const SkewedInfo& other302) { + skewedColNames = other302.skewedColNames; + skewedColValues = other302.skewedColValues; + skewedColValueLocationMaps = other302.skewedColValueLocationMaps; + __isset = other302.__isset; + return *this; +} +void SkewedInfo::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "SkewedInfo("; + out << "skewedColNames=" << to_string(skewedColNames); + out << ", " << "skewedColValues=" << to_string(skewedColValues); + out << ", " << "skewedColValueLocationMaps=" << to_string(skewedColValueLocationMaps); + out << ")"; +} + + +StorageDescriptor::~StorageDescriptor() noexcept { +} + +StorageDescriptor::StorageDescriptor() noexcept + : location(), + inputFormat(), + outputFormat(), + compressed(0), + numBuckets(0), + storedAsSubDirectories(0) { +} + +void StorageDescriptor::__set_cols(const std::vector & val) { + this->cols = val; +} + +void StorageDescriptor::__set_location(const std::string& val) { + this->location = val; +} + +void StorageDescriptor::__set_inputFormat(const std::string& val) { + this->inputFormat = val; +} + +void StorageDescriptor::__set_outputFormat(const std::string& val) { + this->outputFormat = val; +} + +void StorageDescriptor::__set_compressed(const bool val) { + this->compressed = val; +} + +void StorageDescriptor::__set_numBuckets(const int32_t val) { + this->numBuckets = val; +} + +void StorageDescriptor::__set_serdeInfo(const SerDeInfo& val) { + this->serdeInfo = val; +} + +void StorageDescriptor::__set_bucketCols(const std::vector & val) { + this->bucketCols = val; +} + +void StorageDescriptor::__set_sortCols(const std::vector & val) { + this->sortCols = val; +} + +void StorageDescriptor::__set_parameters(const std::map & val) { + this->parameters = val; +} + +void StorageDescriptor::__set_skewedInfo(const SkewedInfo& val) { + this->skewedInfo = val; +__isset.skewedInfo = true; +} + +void StorageDescriptor::__set_storedAsSubDirectories(const bool val) { + this->storedAsSubDirectories = val; +__isset.storedAsSubDirectories = true; +} +std::ostream& operator<<(std::ostream& out, const StorageDescriptor& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->cols.clear(); + uint32_t _size303; + ::apache::thrift::protocol::TType _etype306; + xfer += iprot->readListBegin(_etype306, _size303); + this->cols.resize(_size303); + uint32_t _i307; + for (_i307 = 0; _i307 < _size303; ++_i307) + { + xfer += this->cols[_i307].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.cols = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->location); + this->__isset.location = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->inputFormat); + this->__isset.inputFormat = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->outputFormat); + this->__isset.outputFormat = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->compressed); + this->__isset.compressed = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->numBuckets); + this->__isset.numBuckets = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->serdeInfo.read(iprot); + this->__isset.serdeInfo = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->bucketCols.clear(); + uint32_t _size308; + ::apache::thrift::protocol::TType _etype311; + xfer += iprot->readListBegin(_etype311, _size308); + this->bucketCols.resize(_size308); + uint32_t _i312; + for (_i312 = 0; _i312 < _size308; ++_i312) + { + xfer += iprot->readString(this->bucketCols[_i312]); + } + xfer += iprot->readListEnd(); + } + this->__isset.bucketCols = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->sortCols.clear(); + uint32_t _size313; + ::apache::thrift::protocol::TType _etype316; + xfer += iprot->readListBegin(_etype316, _size313); + this->sortCols.resize(_size313); + uint32_t _i317; + for (_i317 = 0; _i317 < _size313; ++_i317) + { + xfer += this->sortCols[_i317].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.sortCols = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->parameters.clear(); + uint32_t _size318; + ::apache::thrift::protocol::TType _ktype319; + ::apache::thrift::protocol::TType _vtype320; + xfer += iprot->readMapBegin(_ktype319, _vtype320, _size318); + uint32_t _i322; + for (_i322 = 0; _i322 < _size318; ++_i322) + { + std::string _key323; + xfer += iprot->readString(_key323); + std::string& _val324 = this->parameters[_key323]; + xfer += iprot->readString(_val324); + } + xfer += iprot->readMapEnd(); + } + this->__isset.parameters = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 11: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->skewedInfo.read(iprot); + this->__isset.skewedInfo = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 12: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->storedAsSubDirectories); + this->__isset.storedAsSubDirectories = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("StorageDescriptor"); + + xfer += oprot->writeFieldBegin("cols", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->cols.size())); + std::vector ::const_iterator _iter325; + for (_iter325 = this->cols.begin(); _iter325 != this->cols.end(); ++_iter325) + { + xfer += (*_iter325).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("location", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->location); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("inputFormat", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->inputFormat); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("outputFormat", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->outputFormat); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("compressed", ::apache::thrift::protocol::T_BOOL, 5); + xfer += oprot->writeBool(this->compressed); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("numBuckets", ::apache::thrift::protocol::T_I32, 6); + xfer += oprot->writeI32(this->numBuckets); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("serdeInfo", ::apache::thrift::protocol::T_STRUCT, 7); + xfer += this->serdeInfo.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("bucketCols", ::apache::thrift::protocol::T_LIST, 8); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->bucketCols.size())); + std::vector ::const_iterator _iter326; + for (_iter326 = this->bucketCols.begin(); _iter326 != this->bucketCols.end(); ++_iter326) + { + xfer += oprot->writeString((*_iter326)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("sortCols", ::apache::thrift::protocol::T_LIST, 9); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->sortCols.size())); + std::vector ::const_iterator _iter327; + for (_iter327 = this->sortCols.begin(); _iter327 != this->sortCols.end(); ++_iter327) + { + xfer += (*_iter327).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 10); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); + std::map ::const_iterator _iter328; + for (_iter328 = this->parameters.begin(); _iter328 != this->parameters.end(); ++_iter328) + { + xfer += oprot->writeString(_iter328->first); + xfer += oprot->writeString(_iter328->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.skewedInfo) { + xfer += oprot->writeFieldBegin("skewedInfo", ::apache::thrift::protocol::T_STRUCT, 11); + xfer += this->skewedInfo.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.storedAsSubDirectories) { + xfer += oprot->writeFieldBegin("storedAsSubDirectories", ::apache::thrift::protocol::T_BOOL, 12); + xfer += oprot->writeBool(this->storedAsSubDirectories); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(StorageDescriptor &a, StorageDescriptor &b) noexcept { + using ::std::swap; + swap(a.cols, b.cols); + swap(a.location, b.location); + swap(a.inputFormat, b.inputFormat); + swap(a.outputFormat, b.outputFormat); + swap(a.compressed, b.compressed); + swap(a.numBuckets, b.numBuckets); + swap(a.serdeInfo, b.serdeInfo); + swap(a.bucketCols, b.bucketCols); + swap(a.sortCols, b.sortCols); + swap(a.parameters, b.parameters); + swap(a.skewedInfo, b.skewedInfo); + swap(a.storedAsSubDirectories, b.storedAsSubDirectories); + swap(a.__isset, b.__isset); +} + +bool StorageDescriptor::operator==(const StorageDescriptor & rhs) const +{ + if (!(cols == rhs.cols)) + return false; + if (!(location == rhs.location)) + return false; + if (!(inputFormat == rhs.inputFormat)) + return false; + if (!(outputFormat == rhs.outputFormat)) + return false; + if (!(compressed == rhs.compressed)) + return false; + if (!(numBuckets == rhs.numBuckets)) + return false; + if (!(serdeInfo == rhs.serdeInfo)) + return false; + if (!(bucketCols == rhs.bucketCols)) + return false; + if (!(sortCols == rhs.sortCols)) + return false; + if (!(parameters == rhs.parameters)) + return false; + if (__isset.skewedInfo != rhs.__isset.skewedInfo) + return false; + else if (__isset.skewedInfo && !(skewedInfo == rhs.skewedInfo)) + return false; + if (__isset.storedAsSubDirectories != rhs.__isset.storedAsSubDirectories) + return false; + else if (__isset.storedAsSubDirectories && !(storedAsSubDirectories == rhs.storedAsSubDirectories)) + return false; + return true; +} + +StorageDescriptor::StorageDescriptor(const StorageDescriptor& other329) { + cols = other329.cols; + location = other329.location; + inputFormat = other329.inputFormat; + outputFormat = other329.outputFormat; + compressed = other329.compressed; + numBuckets = other329.numBuckets; + serdeInfo = other329.serdeInfo; + bucketCols = other329.bucketCols; + sortCols = other329.sortCols; + parameters = other329.parameters; + skewedInfo = other329.skewedInfo; + storedAsSubDirectories = other329.storedAsSubDirectories; + __isset = other329.__isset; +} +StorageDescriptor& StorageDescriptor::operator=(const StorageDescriptor& other330) { + cols = other330.cols; + location = other330.location; + inputFormat = other330.inputFormat; + outputFormat = other330.outputFormat; + compressed = other330.compressed; + numBuckets = other330.numBuckets; + serdeInfo = other330.serdeInfo; + bucketCols = other330.bucketCols; + sortCols = other330.sortCols; + parameters = other330.parameters; + skewedInfo = other330.skewedInfo; + storedAsSubDirectories = other330.storedAsSubDirectories; + __isset = other330.__isset; + return *this; +} +void StorageDescriptor::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "StorageDescriptor("; + out << "cols=" << to_string(cols); + out << ", " << "location=" << to_string(location); + out << ", " << "inputFormat=" << to_string(inputFormat); + out << ", " << "outputFormat=" << to_string(outputFormat); + out << ", " << "compressed=" << to_string(compressed); + out << ", " << "numBuckets=" << to_string(numBuckets); + out << ", " << "serdeInfo=" << to_string(serdeInfo); + out << ", " << "bucketCols=" << to_string(bucketCols); + out << ", " << "sortCols=" << to_string(sortCols); + out << ", " << "parameters=" << to_string(parameters); + out << ", " << "skewedInfo="; (__isset.skewedInfo ? (out << to_string(skewedInfo)) : (out << "")); + out << ", " << "storedAsSubDirectories="; (__isset.storedAsSubDirectories ? (out << to_string(storedAsSubDirectories)) : (out << "")); + out << ")"; +} + + +CreationMetadata::~CreationMetadata() noexcept { +} + +CreationMetadata::CreationMetadata() noexcept + : catName(), + dbName(), + tblName(), + validTxnList(), + materializationTime(0) { +} + +void CreationMetadata::__set_catName(const std::string& val) { + this->catName = val; +} + +void CreationMetadata::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void CreationMetadata::__set_tblName(const std::string& val) { + this->tblName = val; +} + +void CreationMetadata::__set_tablesUsed(const std::set & val) { + this->tablesUsed = val; +} + +void CreationMetadata::__set_validTxnList(const std::string& val) { + this->validTxnList = val; +__isset.validTxnList = true; +} + +void CreationMetadata::__set_materializationTime(const int64_t val) { + this->materializationTime = val; +__isset.materializationTime = true; +} + +void CreationMetadata::__set_sourceTables(const std::vector & val) { + this->sourceTables = val; +__isset.sourceTables = true; +} +std::ostream& operator<<(std::ostream& out, const CreationMetadata& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t CreationMetadata::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_catName = false; + bool isset_dbName = false; + bool isset_tblName = false; + bool isset_tablesUsed = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + isset_catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tblName); + isset_tblName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_SET) { + { + this->tablesUsed.clear(); + uint32_t _size331; + ::apache::thrift::protocol::TType _etype334; + xfer += iprot->readSetBegin(_etype334, _size331); + uint32_t _i335; + for (_i335 = 0; _i335 < _size331; ++_i335) + { + std::string _elem336; + xfer += iprot->readString(_elem336); + this->tablesUsed.insert(_elem336); + } + xfer += iprot->readSetEnd(); + } + isset_tablesUsed = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validTxnList); + this->__isset.validTxnList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->materializationTime); + this->__isset.materializationTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->sourceTables.clear(); + uint32_t _size337; + ::apache::thrift::protocol::TType _etype340; + xfer += iprot->readListBegin(_etype340, _size337); + this->sourceTables.resize(_size337); + uint32_t _i341; + for (_i341 = 0; _i341 < _size337; ++_i341) + { + xfer += this->sourceTables[_i341].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.sourceTables = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_catName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tblName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tablesUsed) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t CreationMetadata::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CreationMetadata"); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tblName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tablesUsed", ::apache::thrift::protocol::T_SET, 4); + { + xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tablesUsed.size())); + std::set ::const_iterator _iter342; + for (_iter342 = this->tablesUsed.begin(); _iter342 != this->tablesUsed.end(); ++_iter342) + { + xfer += oprot->writeString((*_iter342)); + } + xfer += oprot->writeSetEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.validTxnList) { + xfer += oprot->writeFieldBegin("validTxnList", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->validTxnList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.materializationTime) { + xfer += oprot->writeFieldBegin("materializationTime", ::apache::thrift::protocol::T_I64, 6); + xfer += oprot->writeI64(this->materializationTime); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.sourceTables) { + xfer += oprot->writeFieldBegin("sourceTables", ::apache::thrift::protocol::T_LIST, 7); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->sourceTables.size())); + std::vector ::const_iterator _iter343; + for (_iter343 = this->sourceTables.begin(); _iter343 != this->sourceTables.end(); ++_iter343) + { + xfer += (*_iter343).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CreationMetadata &a, CreationMetadata &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); + swap(a.tablesUsed, b.tablesUsed); + swap(a.validTxnList, b.validTxnList); + swap(a.materializationTime, b.materializationTime); + swap(a.sourceTables, b.sourceTables); + swap(a.__isset, b.__isset); +} + +bool CreationMetadata::operator==(const CreationMetadata & rhs) const +{ + if (!(catName == rhs.catName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + if (!(tablesUsed == rhs.tablesUsed)) + return false; + if (__isset.validTxnList != rhs.__isset.validTxnList) + return false; + else if (__isset.validTxnList && !(validTxnList == rhs.validTxnList)) + return false; + if (__isset.materializationTime != rhs.__isset.materializationTime) + return false; + else if (__isset.materializationTime && !(materializationTime == rhs.materializationTime)) + return false; + if (__isset.sourceTables != rhs.__isset.sourceTables) + return false; + else if (__isset.sourceTables && !(sourceTables == rhs.sourceTables)) + return false; + return true; +} + +CreationMetadata::CreationMetadata(const CreationMetadata& other344) { + catName = other344.catName; + dbName = other344.dbName; + tblName = other344.tblName; + tablesUsed = other344.tablesUsed; + validTxnList = other344.validTxnList; + materializationTime = other344.materializationTime; + sourceTables = other344.sourceTables; + __isset = other344.__isset; +} +CreationMetadata& CreationMetadata::operator=(const CreationMetadata& other345) { + catName = other345.catName; + dbName = other345.dbName; + tblName = other345.tblName; + tablesUsed = other345.tablesUsed; + validTxnList = other345.validTxnList; + materializationTime = other345.materializationTime; + sourceTables = other345.sourceTables; + __isset = other345.__isset; + return *this; +} +void CreationMetadata::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CreationMetadata("; + out << "catName=" << to_string(catName); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "tblName=" << to_string(tblName); + out << ", " << "tablesUsed=" << to_string(tablesUsed); + out << ", " << "validTxnList="; (__isset.validTxnList ? (out << to_string(validTxnList)) : (out << "")); + out << ", " << "materializationTime="; (__isset.materializationTime ? (out << to_string(materializationTime)) : (out << "")); + out << ", " << "sourceTables="; (__isset.sourceTables ? (out << to_string(sourceTables)) : (out << "")); + out << ")"; +} + + +BooleanColumnStatsData::~BooleanColumnStatsData() noexcept { +} + +BooleanColumnStatsData::BooleanColumnStatsData() noexcept + : numTrues(0), + numFalses(0), + numNulls(0), + bitVectors() { +} + +void BooleanColumnStatsData::__set_numTrues(const int64_t val) { + this->numTrues = val; +} + +void BooleanColumnStatsData::__set_numFalses(const int64_t val) { + this->numFalses = val; +} + +void BooleanColumnStatsData::__set_numNulls(const int64_t val) { + this->numNulls = val; +} + +void BooleanColumnStatsData::__set_bitVectors(const std::string& val) { + this->bitVectors = val; +__isset.bitVectors = true; +} +std::ostream& operator<<(std::ostream& out, const BooleanColumnStatsData& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t BooleanColumnStatsData::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_numTrues = false; + bool isset_numFalses = false; + bool isset_numNulls = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->numTrues); + isset_numTrues = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->numFalses); + isset_numFalses = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->numNulls); + isset_numNulls = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->bitVectors); + this->__isset.bitVectors = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_numTrues) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_numFalses) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_numNulls) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t BooleanColumnStatsData::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("BooleanColumnStatsData"); + + xfer += oprot->writeFieldBegin("numTrues", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->numTrues); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("numFalses", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->numFalses); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("numNulls", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->numNulls); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.bitVectors) { + xfer += oprot->writeFieldBegin("bitVectors", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeBinary(this->bitVectors); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(BooleanColumnStatsData &a, BooleanColumnStatsData &b) noexcept { + using ::std::swap; + swap(a.numTrues, b.numTrues); + swap(a.numFalses, b.numFalses); + swap(a.numNulls, b.numNulls); + swap(a.bitVectors, b.bitVectors); + swap(a.__isset, b.__isset); +} + +bool BooleanColumnStatsData::operator==(const BooleanColumnStatsData & rhs) const +{ + if (!(numTrues == rhs.numTrues)) + return false; + if (!(numFalses == rhs.numFalses)) + return false; + if (!(numNulls == rhs.numNulls)) + return false; + if (__isset.bitVectors != rhs.__isset.bitVectors) + return false; + else if (__isset.bitVectors && !(bitVectors == rhs.bitVectors)) + return false; + return true; +} + +BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other346) { + numTrues = other346.numTrues; + numFalses = other346.numFalses; + numNulls = other346.numNulls; + bitVectors = other346.bitVectors; + __isset = other346.__isset; +} +BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other347) { + numTrues = other347.numTrues; + numFalses = other347.numFalses; + numNulls = other347.numNulls; + bitVectors = other347.bitVectors; + __isset = other347.__isset; + return *this; +} +void BooleanColumnStatsData::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "BooleanColumnStatsData("; + out << "numTrues=" << to_string(numTrues); + out << ", " << "numFalses=" << to_string(numFalses); + out << ", " << "numNulls=" << to_string(numNulls); + out << ", " << "bitVectors="; (__isset.bitVectors ? (out << to_string(bitVectors)) : (out << "")); + out << ")"; +} + + +DoubleColumnStatsData::~DoubleColumnStatsData() noexcept { +} + +DoubleColumnStatsData::DoubleColumnStatsData() noexcept + : lowValue(0), + highValue(0), + numNulls(0), + numDVs(0), + bitVectors(), + histogram() { +} + +void DoubleColumnStatsData::__set_lowValue(const double val) { + this->lowValue = val; +__isset.lowValue = true; +} + +void DoubleColumnStatsData::__set_highValue(const double val) { + this->highValue = val; +__isset.highValue = true; +} + +void DoubleColumnStatsData::__set_numNulls(const int64_t val) { + this->numNulls = val; +} + +void DoubleColumnStatsData::__set_numDVs(const int64_t val) { + this->numDVs = val; +} + +void DoubleColumnStatsData::__set_bitVectors(const std::string& val) { + this->bitVectors = val; +__isset.bitVectors = true; +} + +void DoubleColumnStatsData::__set_histogram(const std::string& val) { + this->histogram = val; +__isset.histogram = true; +} +std::ostream& operator<<(std::ostream& out, const DoubleColumnStatsData& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t DoubleColumnStatsData::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_numNulls = false; + bool isset_numDVs = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_DOUBLE) { + xfer += iprot->readDouble(this->lowValue); + this->__isset.lowValue = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_DOUBLE) { + xfer += iprot->readDouble(this->highValue); + this->__isset.highValue = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->numNulls); + isset_numNulls = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->numDVs); + isset_numDVs = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->bitVectors); + this->__isset.bitVectors = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->histogram); + this->__isset.histogram = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_numNulls) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_numDVs) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t DoubleColumnStatsData::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("DoubleColumnStatsData"); + + if (this->__isset.lowValue) { + xfer += oprot->writeFieldBegin("lowValue", ::apache::thrift::protocol::T_DOUBLE, 1); + xfer += oprot->writeDouble(this->lowValue); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.highValue) { + xfer += oprot->writeFieldBegin("highValue", ::apache::thrift::protocol::T_DOUBLE, 2); + xfer += oprot->writeDouble(this->highValue); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("numNulls", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->numNulls); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("numDVs", ::apache::thrift::protocol::T_I64, 4); + xfer += oprot->writeI64(this->numDVs); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.bitVectors) { + xfer += oprot->writeFieldBegin("bitVectors", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeBinary(this->bitVectors); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.histogram) { + xfer += oprot->writeFieldBegin("histogram", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeBinary(this->histogram); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(DoubleColumnStatsData &a, DoubleColumnStatsData &b) noexcept { + using ::std::swap; + swap(a.lowValue, b.lowValue); + swap(a.highValue, b.highValue); + swap(a.numNulls, b.numNulls); + swap(a.numDVs, b.numDVs); + swap(a.bitVectors, b.bitVectors); + swap(a.histogram, b.histogram); + swap(a.__isset, b.__isset); +} + +bool DoubleColumnStatsData::operator==(const DoubleColumnStatsData & rhs) const +{ + if (__isset.lowValue != rhs.__isset.lowValue) + return false; + else if (__isset.lowValue && !(lowValue == rhs.lowValue)) + return false; + if (__isset.highValue != rhs.__isset.highValue) + return false; + else if (__isset.highValue && !(highValue == rhs.highValue)) + return false; + if (!(numNulls == rhs.numNulls)) + return false; + if (!(numDVs == rhs.numDVs)) + return false; + if (__isset.bitVectors != rhs.__isset.bitVectors) + return false; + else if (__isset.bitVectors && !(bitVectors == rhs.bitVectors)) + return false; + if (__isset.histogram != rhs.__isset.histogram) + return false; + else if (__isset.histogram && !(histogram == rhs.histogram)) + return false; + return true; +} + +DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other348) { + lowValue = other348.lowValue; + highValue = other348.highValue; + numNulls = other348.numNulls; + numDVs = other348.numDVs; + bitVectors = other348.bitVectors; + histogram = other348.histogram; + __isset = other348.__isset; +} +DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other349) { + lowValue = other349.lowValue; + highValue = other349.highValue; + numNulls = other349.numNulls; + numDVs = other349.numDVs; + bitVectors = other349.bitVectors; + histogram = other349.histogram; + __isset = other349.__isset; + return *this; +} +void DoubleColumnStatsData::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "DoubleColumnStatsData("; + out << "lowValue="; (__isset.lowValue ? (out << to_string(lowValue)) : (out << "")); + out << ", " << "highValue="; (__isset.highValue ? (out << to_string(highValue)) : (out << "")); + out << ", " << "numNulls=" << to_string(numNulls); + out << ", " << "numDVs=" << to_string(numDVs); + out << ", " << "bitVectors="; (__isset.bitVectors ? (out << to_string(bitVectors)) : (out << "")); + out << ", " << "histogram="; (__isset.histogram ? (out << to_string(histogram)) : (out << "")); + out << ")"; +} + + +LongColumnStatsData::~LongColumnStatsData() noexcept { +} + +LongColumnStatsData::LongColumnStatsData() noexcept + : lowValue(0), + highValue(0), + numNulls(0), + numDVs(0), + bitVectors(), + histogram() { +} + +void LongColumnStatsData::__set_lowValue(const int64_t val) { + this->lowValue = val; +__isset.lowValue = true; +} + +void LongColumnStatsData::__set_highValue(const int64_t val) { + this->highValue = val; +__isset.highValue = true; +} + +void LongColumnStatsData::__set_numNulls(const int64_t val) { + this->numNulls = val; +} + +void LongColumnStatsData::__set_numDVs(const int64_t val) { + this->numDVs = val; +} + +void LongColumnStatsData::__set_bitVectors(const std::string& val) { + this->bitVectors = val; +__isset.bitVectors = true; +} + +void LongColumnStatsData::__set_histogram(const std::string& val) { + this->histogram = val; +__isset.histogram = true; +} +std::ostream& operator<<(std::ostream& out, const LongColumnStatsData& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t LongColumnStatsData::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_numNulls = false; + bool isset_numDVs = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->lowValue); + this->__isset.lowValue = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->highValue); + this->__isset.highValue = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->numNulls); + isset_numNulls = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->numDVs); + isset_numDVs = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->bitVectors); + this->__isset.bitVectors = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->histogram); + this->__isset.histogram = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_numNulls) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_numDVs) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t LongColumnStatsData::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("LongColumnStatsData"); + + if (this->__isset.lowValue) { + xfer += oprot->writeFieldBegin("lowValue", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->lowValue); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.highValue) { + xfer += oprot->writeFieldBegin("highValue", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->highValue); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("numNulls", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->numNulls); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("numDVs", ::apache::thrift::protocol::T_I64, 4); + xfer += oprot->writeI64(this->numDVs); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.bitVectors) { + xfer += oprot->writeFieldBegin("bitVectors", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeBinary(this->bitVectors); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.histogram) { + xfer += oprot->writeFieldBegin("histogram", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeBinary(this->histogram); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(LongColumnStatsData &a, LongColumnStatsData &b) noexcept { + using ::std::swap; + swap(a.lowValue, b.lowValue); + swap(a.highValue, b.highValue); + swap(a.numNulls, b.numNulls); + swap(a.numDVs, b.numDVs); + swap(a.bitVectors, b.bitVectors); + swap(a.histogram, b.histogram); + swap(a.__isset, b.__isset); +} + +bool LongColumnStatsData::operator==(const LongColumnStatsData & rhs) const +{ + if (__isset.lowValue != rhs.__isset.lowValue) + return false; + else if (__isset.lowValue && !(lowValue == rhs.lowValue)) + return false; + if (__isset.highValue != rhs.__isset.highValue) + return false; + else if (__isset.highValue && !(highValue == rhs.highValue)) + return false; + if (!(numNulls == rhs.numNulls)) + return false; + if (!(numDVs == rhs.numDVs)) + return false; + if (__isset.bitVectors != rhs.__isset.bitVectors) + return false; + else if (__isset.bitVectors && !(bitVectors == rhs.bitVectors)) + return false; + if (__isset.histogram != rhs.__isset.histogram) + return false; + else if (__isset.histogram && !(histogram == rhs.histogram)) + return false; + return true; +} + +LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other350) { + lowValue = other350.lowValue; + highValue = other350.highValue; + numNulls = other350.numNulls; + numDVs = other350.numDVs; + bitVectors = other350.bitVectors; + histogram = other350.histogram; + __isset = other350.__isset; +} +LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other351) { + lowValue = other351.lowValue; + highValue = other351.highValue; + numNulls = other351.numNulls; + numDVs = other351.numDVs; + bitVectors = other351.bitVectors; + histogram = other351.histogram; + __isset = other351.__isset; + return *this; +} +void LongColumnStatsData::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "LongColumnStatsData("; + out << "lowValue="; (__isset.lowValue ? (out << to_string(lowValue)) : (out << "")); + out << ", " << "highValue="; (__isset.highValue ? (out << to_string(highValue)) : (out << "")); + out << ", " << "numNulls=" << to_string(numNulls); + out << ", " << "numDVs=" << to_string(numDVs); + out << ", " << "bitVectors="; (__isset.bitVectors ? (out << to_string(bitVectors)) : (out << "")); + out << ", " << "histogram="; (__isset.histogram ? (out << to_string(histogram)) : (out << "")); + out << ")"; +} + + +StringColumnStatsData::~StringColumnStatsData() noexcept { +} + +StringColumnStatsData::StringColumnStatsData() noexcept + : maxColLen(0), + avgColLen(0), + numNulls(0), + numDVs(0), + bitVectors() { +} + +void StringColumnStatsData::__set_maxColLen(const int64_t val) { + this->maxColLen = val; +} + +void StringColumnStatsData::__set_avgColLen(const double val) { + this->avgColLen = val; +} + +void StringColumnStatsData::__set_numNulls(const int64_t val) { + this->numNulls = val; +} + +void StringColumnStatsData::__set_numDVs(const int64_t val) { + this->numDVs = val; +} + +void StringColumnStatsData::__set_bitVectors(const std::string& val) { + this->bitVectors = val; +__isset.bitVectors = true; +} +std::ostream& operator<<(std::ostream& out, const StringColumnStatsData& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t StringColumnStatsData::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_maxColLen = false; + bool isset_avgColLen = false; + bool isset_numNulls = false; + bool isset_numDVs = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->maxColLen); + isset_maxColLen = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_DOUBLE) { + xfer += iprot->readDouble(this->avgColLen); + isset_avgColLen = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->numNulls); + isset_numNulls = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->numDVs); + isset_numDVs = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->bitVectors); + this->__isset.bitVectors = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_maxColLen) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_avgColLen) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_numNulls) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_numDVs) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t StringColumnStatsData::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("StringColumnStatsData"); + + xfer += oprot->writeFieldBegin("maxColLen", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->maxColLen); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("avgColLen", ::apache::thrift::protocol::T_DOUBLE, 2); + xfer += oprot->writeDouble(this->avgColLen); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("numNulls", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->numNulls); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("numDVs", ::apache::thrift::protocol::T_I64, 4); + xfer += oprot->writeI64(this->numDVs); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.bitVectors) { + xfer += oprot->writeFieldBegin("bitVectors", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeBinary(this->bitVectors); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(StringColumnStatsData &a, StringColumnStatsData &b) noexcept { + using ::std::swap; + swap(a.maxColLen, b.maxColLen); + swap(a.avgColLen, b.avgColLen); + swap(a.numNulls, b.numNulls); + swap(a.numDVs, b.numDVs); + swap(a.bitVectors, b.bitVectors); + swap(a.__isset, b.__isset); +} + +bool StringColumnStatsData::operator==(const StringColumnStatsData & rhs) const +{ + if (!(maxColLen == rhs.maxColLen)) + return false; + if (!(avgColLen == rhs.avgColLen)) + return false; + if (!(numNulls == rhs.numNulls)) + return false; + if (!(numDVs == rhs.numDVs)) + return false; + if (__isset.bitVectors != rhs.__isset.bitVectors) + return false; + else if (__isset.bitVectors && !(bitVectors == rhs.bitVectors)) + return false; + return true; +} + +StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other352) { + maxColLen = other352.maxColLen; + avgColLen = other352.avgColLen; + numNulls = other352.numNulls; + numDVs = other352.numDVs; + bitVectors = other352.bitVectors; + __isset = other352.__isset; +} +StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other353) { + maxColLen = other353.maxColLen; + avgColLen = other353.avgColLen; + numNulls = other353.numNulls; + numDVs = other353.numDVs; + bitVectors = other353.bitVectors; + __isset = other353.__isset; + return *this; +} +void StringColumnStatsData::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "StringColumnStatsData("; + out << "maxColLen=" << to_string(maxColLen); + out << ", " << "avgColLen=" << to_string(avgColLen); + out << ", " << "numNulls=" << to_string(numNulls); + out << ", " << "numDVs=" << to_string(numDVs); + out << ", " << "bitVectors="; (__isset.bitVectors ? (out << to_string(bitVectors)) : (out << "")); + out << ")"; +} + + +BinaryColumnStatsData::~BinaryColumnStatsData() noexcept { +} + +BinaryColumnStatsData::BinaryColumnStatsData() noexcept + : maxColLen(0), + avgColLen(0), + numNulls(0), + bitVectors() { +} + +void BinaryColumnStatsData::__set_maxColLen(const int64_t val) { + this->maxColLen = val; +} + +void BinaryColumnStatsData::__set_avgColLen(const double val) { + this->avgColLen = val; +} + +void BinaryColumnStatsData::__set_numNulls(const int64_t val) { + this->numNulls = val; +} + +void BinaryColumnStatsData::__set_bitVectors(const std::string& val) { + this->bitVectors = val; +__isset.bitVectors = true; +} +std::ostream& operator<<(std::ostream& out, const BinaryColumnStatsData& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t BinaryColumnStatsData::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_maxColLen = false; + bool isset_avgColLen = false; + bool isset_numNulls = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->maxColLen); + isset_maxColLen = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_DOUBLE) { + xfer += iprot->readDouble(this->avgColLen); + isset_avgColLen = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->numNulls); + isset_numNulls = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->bitVectors); + this->__isset.bitVectors = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_maxColLen) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_avgColLen) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_numNulls) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t BinaryColumnStatsData::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("BinaryColumnStatsData"); + + xfer += oprot->writeFieldBegin("maxColLen", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->maxColLen); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("avgColLen", ::apache::thrift::protocol::T_DOUBLE, 2); + xfer += oprot->writeDouble(this->avgColLen); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("numNulls", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->numNulls); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.bitVectors) { + xfer += oprot->writeFieldBegin("bitVectors", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeBinary(this->bitVectors); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(BinaryColumnStatsData &a, BinaryColumnStatsData &b) noexcept { + using ::std::swap; + swap(a.maxColLen, b.maxColLen); + swap(a.avgColLen, b.avgColLen); + swap(a.numNulls, b.numNulls); + swap(a.bitVectors, b.bitVectors); + swap(a.__isset, b.__isset); +} + +bool BinaryColumnStatsData::operator==(const BinaryColumnStatsData & rhs) const +{ + if (!(maxColLen == rhs.maxColLen)) + return false; + if (!(avgColLen == rhs.avgColLen)) + return false; + if (!(numNulls == rhs.numNulls)) + return false; + if (__isset.bitVectors != rhs.__isset.bitVectors) + return false; + else if (__isset.bitVectors && !(bitVectors == rhs.bitVectors)) + return false; + return true; +} + +BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other354) { + maxColLen = other354.maxColLen; + avgColLen = other354.avgColLen; + numNulls = other354.numNulls; + bitVectors = other354.bitVectors; + __isset = other354.__isset; +} +BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other355) { + maxColLen = other355.maxColLen; + avgColLen = other355.avgColLen; + numNulls = other355.numNulls; + bitVectors = other355.bitVectors; + __isset = other355.__isset; + return *this; +} +void BinaryColumnStatsData::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "BinaryColumnStatsData("; + out << "maxColLen=" << to_string(maxColLen); + out << ", " << "avgColLen=" << to_string(avgColLen); + out << ", " << "numNulls=" << to_string(numNulls); + out << ", " << "bitVectors="; (__isset.bitVectors ? (out << to_string(bitVectors)) : (out << "")); + out << ")"; +} + + +Decimal::~Decimal() noexcept { +} + +Decimal::Decimal() noexcept + : scale(0), + unscaled() { +} + +void Decimal::__set_scale(const int16_t val) { + this->scale = val; +} + +void Decimal::__set_unscaled(const std::string& val) { + this->unscaled = val; +} +std::ostream& operator<<(std::ostream& out, const Decimal& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Decimal::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_scale = false; + bool isset_unscaled = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 3: + if (ftype == ::apache::thrift::protocol::T_I16) { + xfer += iprot->readI16(this->scale); + isset_scale = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->unscaled); + isset_unscaled = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_scale) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_unscaled) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Decimal::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Decimal"); + + xfer += oprot->writeFieldBegin("unscaled", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeBinary(this->unscaled); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("scale", ::apache::thrift::protocol::T_I16, 3); + xfer += oprot->writeI16(this->scale); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Decimal &a, Decimal &b) noexcept { + using ::std::swap; + swap(a.scale, b.scale); + swap(a.unscaled, b.unscaled); +} + +bool Decimal::operator==(const Decimal & rhs) const +{ + if (!(scale == rhs.scale)) + return false; + if (!(unscaled == rhs.unscaled)) + return false; + return true; +} + +Decimal::Decimal(const Decimal& other356) { + scale = other356.scale; + unscaled = other356.unscaled; +} +Decimal& Decimal::operator=(const Decimal& other357) { + scale = other357.scale; + unscaled = other357.unscaled; + return *this; +} +void Decimal::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Decimal("; + out << "scale=" << to_string(scale); + out << ", " << "unscaled=" << to_string(unscaled); + out << ")"; +} + + +DecimalColumnStatsData::~DecimalColumnStatsData() noexcept { +} + +DecimalColumnStatsData::DecimalColumnStatsData() noexcept + : numNulls(0), + numDVs(0), + bitVectors(), + histogram() { +} + +void DecimalColumnStatsData::__set_lowValue(const Decimal& val) { + this->lowValue = val; +__isset.lowValue = true; +} + +void DecimalColumnStatsData::__set_highValue(const Decimal& val) { + this->highValue = val; +__isset.highValue = true; +} + +void DecimalColumnStatsData::__set_numNulls(const int64_t val) { + this->numNulls = val; +} + +void DecimalColumnStatsData::__set_numDVs(const int64_t val) { + this->numDVs = val; +} + +void DecimalColumnStatsData::__set_bitVectors(const std::string& val) { + this->bitVectors = val; +__isset.bitVectors = true; +} + +void DecimalColumnStatsData::__set_histogram(const std::string& val) { + this->histogram = val; +__isset.histogram = true; +} +std::ostream& operator<<(std::ostream& out, const DecimalColumnStatsData& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t DecimalColumnStatsData::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_numNulls = false; + bool isset_numDVs = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->lowValue.read(iprot); + this->__isset.lowValue = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->highValue.read(iprot); + this->__isset.highValue = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->numNulls); + isset_numNulls = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->numDVs); + isset_numDVs = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->bitVectors); + this->__isset.bitVectors = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->histogram); + this->__isset.histogram = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_numNulls) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_numDVs) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t DecimalColumnStatsData::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("DecimalColumnStatsData"); + + if (this->__isset.lowValue) { + xfer += oprot->writeFieldBegin("lowValue", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->lowValue.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.highValue) { + xfer += oprot->writeFieldBegin("highValue", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->highValue.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("numNulls", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->numNulls); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("numDVs", ::apache::thrift::protocol::T_I64, 4); + xfer += oprot->writeI64(this->numDVs); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.bitVectors) { + xfer += oprot->writeFieldBegin("bitVectors", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeBinary(this->bitVectors); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.histogram) { + xfer += oprot->writeFieldBegin("histogram", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeBinary(this->histogram); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(DecimalColumnStatsData &a, DecimalColumnStatsData &b) noexcept { + using ::std::swap; + swap(a.lowValue, b.lowValue); + swap(a.highValue, b.highValue); + swap(a.numNulls, b.numNulls); + swap(a.numDVs, b.numDVs); + swap(a.bitVectors, b.bitVectors); + swap(a.histogram, b.histogram); + swap(a.__isset, b.__isset); +} + +bool DecimalColumnStatsData::operator==(const DecimalColumnStatsData & rhs) const +{ + if (__isset.lowValue != rhs.__isset.lowValue) + return false; + else if (__isset.lowValue && !(lowValue == rhs.lowValue)) + return false; + if (__isset.highValue != rhs.__isset.highValue) + return false; + else if (__isset.highValue && !(highValue == rhs.highValue)) + return false; + if (!(numNulls == rhs.numNulls)) + return false; + if (!(numDVs == rhs.numDVs)) + return false; + if (__isset.bitVectors != rhs.__isset.bitVectors) + return false; + else if (__isset.bitVectors && !(bitVectors == rhs.bitVectors)) + return false; + if (__isset.histogram != rhs.__isset.histogram) + return false; + else if (__isset.histogram && !(histogram == rhs.histogram)) + return false; + return true; +} + +DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other358) { + lowValue = other358.lowValue; + highValue = other358.highValue; + numNulls = other358.numNulls; + numDVs = other358.numDVs; + bitVectors = other358.bitVectors; + histogram = other358.histogram; + __isset = other358.__isset; +} +DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other359) { + lowValue = other359.lowValue; + highValue = other359.highValue; + numNulls = other359.numNulls; + numDVs = other359.numDVs; + bitVectors = other359.bitVectors; + histogram = other359.histogram; + __isset = other359.__isset; + return *this; +} +void DecimalColumnStatsData::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "DecimalColumnStatsData("; + out << "lowValue="; (__isset.lowValue ? (out << to_string(lowValue)) : (out << "")); + out << ", " << "highValue="; (__isset.highValue ? (out << to_string(highValue)) : (out << "")); + out << ", " << "numNulls=" << to_string(numNulls); + out << ", " << "numDVs=" << to_string(numDVs); + out << ", " << "bitVectors="; (__isset.bitVectors ? (out << to_string(bitVectors)) : (out << "")); + out << ", " << "histogram="; (__isset.histogram ? (out << to_string(histogram)) : (out << "")); + out << ")"; +} + + +Date::~Date() noexcept { +} + +Date::Date() noexcept + : daysSinceEpoch(0) { +} + +void Date::__set_daysSinceEpoch(const int64_t val) { + this->daysSinceEpoch = val; +} +std::ostream& operator<<(std::ostream& out, const Date& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Date::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_daysSinceEpoch = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->daysSinceEpoch); + isset_daysSinceEpoch = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_daysSinceEpoch) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Date::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Date"); + + xfer += oprot->writeFieldBegin("daysSinceEpoch", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->daysSinceEpoch); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Date &a, Date &b) noexcept { + using ::std::swap; + swap(a.daysSinceEpoch, b.daysSinceEpoch); +} + +bool Date::operator==(const Date & rhs) const +{ + if (!(daysSinceEpoch == rhs.daysSinceEpoch)) + return false; + return true; +} + +Date::Date(const Date& other360) noexcept { + daysSinceEpoch = other360.daysSinceEpoch; +} +Date& Date::operator=(const Date& other361) noexcept { + daysSinceEpoch = other361.daysSinceEpoch; + return *this; +} +void Date::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Date("; + out << "daysSinceEpoch=" << to_string(daysSinceEpoch); + out << ")"; +} + + +DateColumnStatsData::~DateColumnStatsData() noexcept { +} + +DateColumnStatsData::DateColumnStatsData() noexcept + : numNulls(0), + numDVs(0), + bitVectors(), + histogram() { +} + +void DateColumnStatsData::__set_lowValue(const Date& val) { + this->lowValue = val; +__isset.lowValue = true; +} + +void DateColumnStatsData::__set_highValue(const Date& val) { + this->highValue = val; +__isset.highValue = true; +} + +void DateColumnStatsData::__set_numNulls(const int64_t val) { + this->numNulls = val; +} + +void DateColumnStatsData::__set_numDVs(const int64_t val) { + this->numDVs = val; +} + +void DateColumnStatsData::__set_bitVectors(const std::string& val) { + this->bitVectors = val; +__isset.bitVectors = true; +} + +void DateColumnStatsData::__set_histogram(const std::string& val) { + this->histogram = val; +__isset.histogram = true; +} +std::ostream& operator<<(std::ostream& out, const DateColumnStatsData& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t DateColumnStatsData::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_numNulls = false; + bool isset_numDVs = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->lowValue.read(iprot); + this->__isset.lowValue = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->highValue.read(iprot); + this->__isset.highValue = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->numNulls); + isset_numNulls = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->numDVs); + isset_numDVs = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->bitVectors); + this->__isset.bitVectors = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->histogram); + this->__isset.histogram = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_numNulls) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_numDVs) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t DateColumnStatsData::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("DateColumnStatsData"); + + if (this->__isset.lowValue) { + xfer += oprot->writeFieldBegin("lowValue", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->lowValue.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.highValue) { + xfer += oprot->writeFieldBegin("highValue", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->highValue.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("numNulls", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->numNulls); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("numDVs", ::apache::thrift::protocol::T_I64, 4); + xfer += oprot->writeI64(this->numDVs); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.bitVectors) { + xfer += oprot->writeFieldBegin("bitVectors", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeBinary(this->bitVectors); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.histogram) { + xfer += oprot->writeFieldBegin("histogram", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeBinary(this->histogram); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(DateColumnStatsData &a, DateColumnStatsData &b) noexcept { + using ::std::swap; + swap(a.lowValue, b.lowValue); + swap(a.highValue, b.highValue); + swap(a.numNulls, b.numNulls); + swap(a.numDVs, b.numDVs); + swap(a.bitVectors, b.bitVectors); + swap(a.histogram, b.histogram); + swap(a.__isset, b.__isset); +} + +bool DateColumnStatsData::operator==(const DateColumnStatsData & rhs) const +{ + if (__isset.lowValue != rhs.__isset.lowValue) + return false; + else if (__isset.lowValue && !(lowValue == rhs.lowValue)) + return false; + if (__isset.highValue != rhs.__isset.highValue) + return false; + else if (__isset.highValue && !(highValue == rhs.highValue)) + return false; + if (!(numNulls == rhs.numNulls)) + return false; + if (!(numDVs == rhs.numDVs)) + return false; + if (__isset.bitVectors != rhs.__isset.bitVectors) + return false; + else if (__isset.bitVectors && !(bitVectors == rhs.bitVectors)) + return false; + if (__isset.histogram != rhs.__isset.histogram) + return false; + else if (__isset.histogram && !(histogram == rhs.histogram)) + return false; + return true; +} + +DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other362) { + lowValue = other362.lowValue; + highValue = other362.highValue; + numNulls = other362.numNulls; + numDVs = other362.numDVs; + bitVectors = other362.bitVectors; + histogram = other362.histogram; + __isset = other362.__isset; +} +DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other363) { + lowValue = other363.lowValue; + highValue = other363.highValue; + numNulls = other363.numNulls; + numDVs = other363.numDVs; + bitVectors = other363.bitVectors; + histogram = other363.histogram; + __isset = other363.__isset; + return *this; +} +void DateColumnStatsData::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "DateColumnStatsData("; + out << "lowValue="; (__isset.lowValue ? (out << to_string(lowValue)) : (out << "")); + out << ", " << "highValue="; (__isset.highValue ? (out << to_string(highValue)) : (out << "")); + out << ", " << "numNulls=" << to_string(numNulls); + out << ", " << "numDVs=" << to_string(numDVs); + out << ", " << "bitVectors="; (__isset.bitVectors ? (out << to_string(bitVectors)) : (out << "")); + out << ", " << "histogram="; (__isset.histogram ? (out << to_string(histogram)) : (out << "")); + out << ")"; +} + + +Timestamp::~Timestamp() noexcept { +} + +Timestamp::Timestamp() noexcept + : secondsSinceEpoch(0) { +} + +void Timestamp::__set_secondsSinceEpoch(const int64_t val) { + this->secondsSinceEpoch = val; +} +std::ostream& operator<<(std::ostream& out, const Timestamp& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Timestamp::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_secondsSinceEpoch = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->secondsSinceEpoch); + isset_secondsSinceEpoch = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_secondsSinceEpoch) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Timestamp::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Timestamp"); + + xfer += oprot->writeFieldBegin("secondsSinceEpoch", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->secondsSinceEpoch); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Timestamp &a, Timestamp &b) noexcept { + using ::std::swap; + swap(a.secondsSinceEpoch, b.secondsSinceEpoch); +} + +bool Timestamp::operator==(const Timestamp & rhs) const +{ + if (!(secondsSinceEpoch == rhs.secondsSinceEpoch)) + return false; + return true; +} + +Timestamp::Timestamp(const Timestamp& other364) noexcept { + secondsSinceEpoch = other364.secondsSinceEpoch; +} +Timestamp& Timestamp::operator=(const Timestamp& other365) noexcept { + secondsSinceEpoch = other365.secondsSinceEpoch; + return *this; +} +void Timestamp::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Timestamp("; + out << "secondsSinceEpoch=" << to_string(secondsSinceEpoch); + out << ")"; +} + + +TimestampColumnStatsData::~TimestampColumnStatsData() noexcept { +} + +TimestampColumnStatsData::TimestampColumnStatsData() noexcept + : numNulls(0), + numDVs(0), + bitVectors(), + histogram() { +} + +void TimestampColumnStatsData::__set_lowValue(const Timestamp& val) { + this->lowValue = val; +__isset.lowValue = true; +} + +void TimestampColumnStatsData::__set_highValue(const Timestamp& val) { + this->highValue = val; +__isset.highValue = true; +} + +void TimestampColumnStatsData::__set_numNulls(const int64_t val) { + this->numNulls = val; +} + +void TimestampColumnStatsData::__set_numDVs(const int64_t val) { + this->numDVs = val; +} + +void TimestampColumnStatsData::__set_bitVectors(const std::string& val) { + this->bitVectors = val; +__isset.bitVectors = true; +} + +void TimestampColumnStatsData::__set_histogram(const std::string& val) { + this->histogram = val; +__isset.histogram = true; +} +std::ostream& operator<<(std::ostream& out, const TimestampColumnStatsData& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t TimestampColumnStatsData::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_numNulls = false; + bool isset_numDVs = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->lowValue.read(iprot); + this->__isset.lowValue = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->highValue.read(iprot); + this->__isset.highValue = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->numNulls); + isset_numNulls = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->numDVs); + isset_numDVs = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->bitVectors); + this->__isset.bitVectors = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->histogram); + this->__isset.histogram = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_numNulls) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_numDVs) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t TimestampColumnStatsData::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("TimestampColumnStatsData"); + + if (this->__isset.lowValue) { + xfer += oprot->writeFieldBegin("lowValue", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->lowValue.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.highValue) { + xfer += oprot->writeFieldBegin("highValue", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->highValue.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("numNulls", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->numNulls); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("numDVs", ::apache::thrift::protocol::T_I64, 4); + xfer += oprot->writeI64(this->numDVs); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.bitVectors) { + xfer += oprot->writeFieldBegin("bitVectors", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeBinary(this->bitVectors); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.histogram) { + xfer += oprot->writeFieldBegin("histogram", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeBinary(this->histogram); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(TimestampColumnStatsData &a, TimestampColumnStatsData &b) noexcept { + using ::std::swap; + swap(a.lowValue, b.lowValue); + swap(a.highValue, b.highValue); + swap(a.numNulls, b.numNulls); + swap(a.numDVs, b.numDVs); + swap(a.bitVectors, b.bitVectors); + swap(a.histogram, b.histogram); + swap(a.__isset, b.__isset); +} + +bool TimestampColumnStatsData::operator==(const TimestampColumnStatsData & rhs) const +{ + if (__isset.lowValue != rhs.__isset.lowValue) + return false; + else if (__isset.lowValue && !(lowValue == rhs.lowValue)) + return false; + if (__isset.highValue != rhs.__isset.highValue) + return false; + else if (__isset.highValue && !(highValue == rhs.highValue)) + return false; + if (!(numNulls == rhs.numNulls)) + return false; + if (!(numDVs == rhs.numDVs)) + return false; + if (__isset.bitVectors != rhs.__isset.bitVectors) + return false; + else if (__isset.bitVectors && !(bitVectors == rhs.bitVectors)) + return false; + if (__isset.histogram != rhs.__isset.histogram) + return false; + else if (__isset.histogram && !(histogram == rhs.histogram)) + return false; + return true; +} + +TimestampColumnStatsData::TimestampColumnStatsData(const TimestampColumnStatsData& other366) { + lowValue = other366.lowValue; + highValue = other366.highValue; + numNulls = other366.numNulls; + numDVs = other366.numDVs; + bitVectors = other366.bitVectors; + histogram = other366.histogram; + __isset = other366.__isset; +} +TimestampColumnStatsData& TimestampColumnStatsData::operator=(const TimestampColumnStatsData& other367) { + lowValue = other367.lowValue; + highValue = other367.highValue; + numNulls = other367.numNulls; + numDVs = other367.numDVs; + bitVectors = other367.bitVectors; + histogram = other367.histogram; + __isset = other367.__isset; + return *this; +} +void TimestampColumnStatsData::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "TimestampColumnStatsData("; + out << "lowValue="; (__isset.lowValue ? (out << to_string(lowValue)) : (out << "")); + out << ", " << "highValue="; (__isset.highValue ? (out << to_string(highValue)) : (out << "")); + out << ", " << "numNulls=" << to_string(numNulls); + out << ", " << "numDVs=" << to_string(numDVs); + out << ", " << "bitVectors="; (__isset.bitVectors ? (out << to_string(bitVectors)) : (out << "")); + out << ", " << "histogram="; (__isset.histogram ? (out << to_string(histogram)) : (out << "")); + out << ")"; +} + + +ColumnStatisticsData::~ColumnStatisticsData() noexcept { +} + +ColumnStatisticsData::ColumnStatisticsData() noexcept { +} + +void ColumnStatisticsData::__set_booleanStats(const BooleanColumnStatsData& val) { + this->booleanStats = val; +__isset.booleanStats = true; +} + +void ColumnStatisticsData::__set_longStats(const LongColumnStatsData& val) { + this->longStats = val; +__isset.longStats = true; +} + +void ColumnStatisticsData::__set_doubleStats(const DoubleColumnStatsData& val) { + this->doubleStats = val; +__isset.doubleStats = true; +} + +void ColumnStatisticsData::__set_stringStats(const StringColumnStatsData& val) { + this->stringStats = val; +__isset.stringStats = true; +} + +void ColumnStatisticsData::__set_binaryStats(const BinaryColumnStatsData& val) { + this->binaryStats = val; +__isset.binaryStats = true; +} + +void ColumnStatisticsData::__set_decimalStats(const DecimalColumnStatsData& val) { + this->decimalStats = val; +__isset.decimalStats = true; +} + +void ColumnStatisticsData::__set_dateStats(const DateColumnStatsData& val) { + this->dateStats = val; +__isset.dateStats = true; +} + +void ColumnStatisticsData::__set_timestampStats(const TimestampColumnStatsData& val) { + this->timestampStats = val; +__isset.timestampStats = true; +} +std::ostream& operator<<(std::ostream& out, const ColumnStatisticsData& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ColumnStatisticsData::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->booleanStats.read(iprot); + this->__isset.booleanStats = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->longStats.read(iprot); + this->__isset.longStats = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->doubleStats.read(iprot); + this->__isset.doubleStats = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->stringStats.read(iprot); + this->__isset.stringStats = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->binaryStats.read(iprot); + this->__isset.binaryStats = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->decimalStats.read(iprot); + this->__isset.decimalStats = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->dateStats.read(iprot); + this->__isset.dateStats = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->timestampStats.read(iprot); + this->__isset.timestampStats = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ColumnStatisticsData::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ColumnStatisticsData"); + + if (this->__isset.booleanStats) { + xfer += oprot->writeFieldBegin("booleanStats", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->booleanStats.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.longStats) { + xfer += oprot->writeFieldBegin("longStats", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->longStats.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.doubleStats) { + xfer += oprot->writeFieldBegin("doubleStats", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->doubleStats.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.stringStats) { + xfer += oprot->writeFieldBegin("stringStats", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->stringStats.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.binaryStats) { + xfer += oprot->writeFieldBegin("binaryStats", ::apache::thrift::protocol::T_STRUCT, 5); + xfer += this->binaryStats.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.decimalStats) { + xfer += oprot->writeFieldBegin("decimalStats", ::apache::thrift::protocol::T_STRUCT, 6); + xfer += this->decimalStats.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.dateStats) { + xfer += oprot->writeFieldBegin("dateStats", ::apache::thrift::protocol::T_STRUCT, 7); + xfer += this->dateStats.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.timestampStats) { + xfer += oprot->writeFieldBegin("timestampStats", ::apache::thrift::protocol::T_STRUCT, 8); + xfer += this->timestampStats.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ColumnStatisticsData &a, ColumnStatisticsData &b) noexcept { + using ::std::swap; + swap(a.booleanStats, b.booleanStats); + swap(a.longStats, b.longStats); + swap(a.doubleStats, b.doubleStats); + swap(a.stringStats, b.stringStats); + swap(a.binaryStats, b.binaryStats); + swap(a.decimalStats, b.decimalStats); + swap(a.dateStats, b.dateStats); + swap(a.timestampStats, b.timestampStats); + swap(a.__isset, b.__isset); +} + +bool ColumnStatisticsData::operator==(const ColumnStatisticsData & rhs) const +{ + if (__isset.booleanStats != rhs.__isset.booleanStats) + return false; + else if (__isset.booleanStats && !(booleanStats == rhs.booleanStats)) + return false; + if (__isset.longStats != rhs.__isset.longStats) + return false; + else if (__isset.longStats && !(longStats == rhs.longStats)) + return false; + if (__isset.doubleStats != rhs.__isset.doubleStats) + return false; + else if (__isset.doubleStats && !(doubleStats == rhs.doubleStats)) + return false; + if (__isset.stringStats != rhs.__isset.stringStats) + return false; + else if (__isset.stringStats && !(stringStats == rhs.stringStats)) + return false; + if (__isset.binaryStats != rhs.__isset.binaryStats) + return false; + else if (__isset.binaryStats && !(binaryStats == rhs.binaryStats)) + return false; + if (__isset.decimalStats != rhs.__isset.decimalStats) + return false; + else if (__isset.decimalStats && !(decimalStats == rhs.decimalStats)) + return false; + if (__isset.dateStats != rhs.__isset.dateStats) + return false; + else if (__isset.dateStats && !(dateStats == rhs.dateStats)) + return false; + if (__isset.timestampStats != rhs.__isset.timestampStats) + return false; + else if (__isset.timestampStats && !(timestampStats == rhs.timestampStats)) + return false; + return true; +} + +ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other368) { + booleanStats = other368.booleanStats; + longStats = other368.longStats; + doubleStats = other368.doubleStats; + stringStats = other368.stringStats; + binaryStats = other368.binaryStats; + decimalStats = other368.decimalStats; + dateStats = other368.dateStats; + timestampStats = other368.timestampStats; + __isset = other368.__isset; +} +ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other369) { + booleanStats = other369.booleanStats; + longStats = other369.longStats; + doubleStats = other369.doubleStats; + stringStats = other369.stringStats; + binaryStats = other369.binaryStats; + decimalStats = other369.decimalStats; + dateStats = other369.dateStats; + timestampStats = other369.timestampStats; + __isset = other369.__isset; + return *this; +} +void ColumnStatisticsData::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ColumnStatisticsData("; + out << "booleanStats="; (__isset.booleanStats ? (out << to_string(booleanStats)) : (out << "")); + out << ", " << "longStats="; (__isset.longStats ? (out << to_string(longStats)) : (out << "")); + out << ", " << "doubleStats="; (__isset.doubleStats ? (out << to_string(doubleStats)) : (out << "")); + out << ", " << "stringStats="; (__isset.stringStats ? (out << to_string(stringStats)) : (out << "")); + out << ", " << "binaryStats="; (__isset.binaryStats ? (out << to_string(binaryStats)) : (out << "")); + out << ", " << "decimalStats="; (__isset.decimalStats ? (out << to_string(decimalStats)) : (out << "")); + out << ", " << "dateStats="; (__isset.dateStats ? (out << to_string(dateStats)) : (out << "")); + out << ", " << "timestampStats="; (__isset.timestampStats ? (out << to_string(timestampStats)) : (out << "")); + out << ")"; +} + + +ColumnStatisticsObj::~ColumnStatisticsObj() noexcept { +} + +ColumnStatisticsObj::ColumnStatisticsObj() noexcept + : colName(), + colType() { +} + +void ColumnStatisticsObj::__set_colName(const std::string& val) { + this->colName = val; +} + +void ColumnStatisticsObj::__set_colType(const std::string& val) { + this->colType = val; +} + +void ColumnStatisticsObj::__set_statsData(const ColumnStatisticsData& val) { + this->statsData = val; +} +std::ostream& operator<<(std::ostream& out, const ColumnStatisticsObj& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ColumnStatisticsObj::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_colName = false; + bool isset_colType = false; + bool isset_statsData = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->colName); + isset_colName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->colType); + isset_colType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->statsData.read(iprot); + isset_statsData = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_colName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_colType) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_statsData) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ColumnStatisticsObj::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ColumnStatisticsObj"); + + xfer += oprot->writeFieldBegin("colName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->colName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("colType", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->colType); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("statsData", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->statsData.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ColumnStatisticsObj &a, ColumnStatisticsObj &b) noexcept { + using ::std::swap; + swap(a.colName, b.colName); + swap(a.colType, b.colType); + swap(a.statsData, b.statsData); +} + +bool ColumnStatisticsObj::operator==(const ColumnStatisticsObj & rhs) const +{ + if (!(colName == rhs.colName)) + return false; + if (!(colType == rhs.colType)) + return false; + if (!(statsData == rhs.statsData)) + return false; + return true; +} + +ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other370) { + colName = other370.colName; + colType = other370.colType; + statsData = other370.statsData; +} +ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other371) { + colName = other371.colName; + colType = other371.colType; + statsData = other371.statsData; + return *this; +} +void ColumnStatisticsObj::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ColumnStatisticsObj("; + out << "colName=" << to_string(colName); + out << ", " << "colType=" << to_string(colType); + out << ", " << "statsData=" << to_string(statsData); + out << ")"; +} + + +ColumnStatisticsDesc::~ColumnStatisticsDesc() noexcept { +} + +ColumnStatisticsDesc::ColumnStatisticsDesc() noexcept + : isTblLevel(0), + dbName(), + tableName(), + partName(), + lastAnalyzed(0), + catName() { +} + +void ColumnStatisticsDesc::__set_isTblLevel(const bool val) { + this->isTblLevel = val; +} + +void ColumnStatisticsDesc::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void ColumnStatisticsDesc::__set_tableName(const std::string& val) { + this->tableName = val; +} + +void ColumnStatisticsDesc::__set_partName(const std::string& val) { + this->partName = val; +__isset.partName = true; +} + +void ColumnStatisticsDesc::__set_lastAnalyzed(const int64_t val) { + this->lastAnalyzed = val; +__isset.lastAnalyzed = true; +} + +void ColumnStatisticsDesc::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} +std::ostream& operator<<(std::ostream& out, const ColumnStatisticsDesc& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ColumnStatisticsDesc::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_isTblLevel = false; + bool isset_dbName = false; + bool isset_tableName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isTblLevel); + isset_isTblLevel = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + isset_tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->partName); + this->__isset.partName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->lastAnalyzed); + this->__isset.lastAnalyzed = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_isTblLevel) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tableName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ColumnStatisticsDesc::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ColumnStatisticsDesc"); + + xfer += oprot->writeFieldBegin("isTblLevel", ::apache::thrift::protocol::T_BOOL, 1); + xfer += oprot->writeBool(this->isTblLevel); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.partName) { + xfer += oprot->writeFieldBegin("partName", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->partName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.lastAnalyzed) { + xfer += oprot->writeFieldBegin("lastAnalyzed", ::apache::thrift::protocol::T_I64, 5); + xfer += oprot->writeI64(this->lastAnalyzed); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ColumnStatisticsDesc &a, ColumnStatisticsDesc &b) noexcept { + using ::std::swap; + swap(a.isTblLevel, b.isTblLevel); + swap(a.dbName, b.dbName); + swap(a.tableName, b.tableName); + swap(a.partName, b.partName); + swap(a.lastAnalyzed, b.lastAnalyzed); + swap(a.catName, b.catName); + swap(a.__isset, b.__isset); +} + +bool ColumnStatisticsDesc::operator==(const ColumnStatisticsDesc & rhs) const +{ + if (!(isTblLevel == rhs.isTblLevel)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (__isset.partName != rhs.__isset.partName) + return false; + else if (__isset.partName && !(partName == rhs.partName)) + return false; + if (__isset.lastAnalyzed != rhs.__isset.lastAnalyzed) + return false; + else if (__isset.lastAnalyzed && !(lastAnalyzed == rhs.lastAnalyzed)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + return true; +} + +ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other372) { + isTblLevel = other372.isTblLevel; + dbName = other372.dbName; + tableName = other372.tableName; + partName = other372.partName; + lastAnalyzed = other372.lastAnalyzed; + catName = other372.catName; + __isset = other372.__isset; +} +ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other373) { + isTblLevel = other373.isTblLevel; + dbName = other373.dbName; + tableName = other373.tableName; + partName = other373.partName; + lastAnalyzed = other373.lastAnalyzed; + catName = other373.catName; + __isset = other373.__isset; + return *this; +} +void ColumnStatisticsDesc::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ColumnStatisticsDesc("; + out << "isTblLevel=" << to_string(isTblLevel); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "tableName=" << to_string(tableName); + out << ", " << "partName="; (__isset.partName ? (out << to_string(partName)) : (out << "")); + out << ", " << "lastAnalyzed="; (__isset.lastAnalyzed ? (out << to_string(lastAnalyzed)) : (out << "")); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ")"; +} + + +ColumnStatistics::~ColumnStatistics() noexcept { +} + +ColumnStatistics::ColumnStatistics() : isStatsCompliant(0), + engine("hive") { +} + +void ColumnStatistics::__set_statsDesc(const ColumnStatisticsDesc& val) { + this->statsDesc = val; +} + +void ColumnStatistics::__set_statsObj(const std::vector & val) { + this->statsObj = val; +} + +void ColumnStatistics::__set_isStatsCompliant(const bool val) { + this->isStatsCompliant = val; +__isset.isStatsCompliant = true; +} + +void ColumnStatistics::__set_engine(const std::string& val) { + this->engine = val; +__isset.engine = true; +} +std::ostream& operator<<(std::ostream& out, const ColumnStatistics& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ColumnStatistics::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_statsDesc = false; + bool isset_statsObj = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->statsDesc.read(iprot); + isset_statsDesc = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->statsObj.clear(); + uint32_t _size374; + ::apache::thrift::protocol::TType _etype377; + xfer += iprot->readListBegin(_etype377, _size374); + this->statsObj.resize(_size374); + uint32_t _i378; + for (_i378 = 0; _i378 < _size374; ++_i378) + { + xfer += this->statsObj[_i378].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_statsObj = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isStatsCompliant); + this->__isset.isStatsCompliant = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->engine); + this->__isset.engine = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_statsDesc) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_statsObj) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ColumnStatistics::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ColumnStatistics"); + + xfer += oprot->writeFieldBegin("statsDesc", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->statsDesc.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("statsObj", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->statsObj.size())); + std::vector ::const_iterator _iter379; + for (_iter379 = this->statsObj.begin(); _iter379 != this->statsObj.end(); ++_iter379) + { + xfer += (*_iter379).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.isStatsCompliant) { + xfer += oprot->writeFieldBegin("isStatsCompliant", ::apache::thrift::protocol::T_BOOL, 3); + xfer += oprot->writeBool(this->isStatsCompliant); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.engine) { + xfer += oprot->writeFieldBegin("engine", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->engine); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ColumnStatistics &a, ColumnStatistics &b) noexcept { + using ::std::swap; + swap(a.statsDesc, b.statsDesc); + swap(a.statsObj, b.statsObj); + swap(a.isStatsCompliant, b.isStatsCompliant); + swap(a.engine, b.engine); + swap(a.__isset, b.__isset); +} + +bool ColumnStatistics::operator==(const ColumnStatistics & rhs) const +{ + if (!(statsDesc == rhs.statsDesc)) + return false; + if (!(statsObj == rhs.statsObj)) + return false; + if (__isset.isStatsCompliant != rhs.__isset.isStatsCompliant) + return false; + else if (__isset.isStatsCompliant && !(isStatsCompliant == rhs.isStatsCompliant)) + return false; + if (__isset.engine != rhs.__isset.engine) + return false; + else if (__isset.engine && !(engine == rhs.engine)) + return false; + return true; +} + +ColumnStatistics::ColumnStatistics(const ColumnStatistics& other380) { + statsDesc = other380.statsDesc; + statsObj = other380.statsObj; + isStatsCompliant = other380.isStatsCompliant; + engine = other380.engine; + __isset = other380.__isset; +} +ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other381) { + statsDesc = other381.statsDesc; + statsObj = other381.statsObj; + isStatsCompliant = other381.isStatsCompliant; + engine = other381.engine; + __isset = other381.__isset; + return *this; +} +void ColumnStatistics::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ColumnStatistics("; + out << "statsDesc=" << to_string(statsDesc); + out << ", " << "statsObj=" << to_string(statsObj); + out << ", " << "isStatsCompliant="; (__isset.isStatsCompliant ? (out << to_string(isStatsCompliant)) : (out << "")); + out << ", " << "engine="; (__isset.engine ? (out << to_string(engine)) : (out << "")); + out << ")"; +} + + +FileMetadata::~FileMetadata() noexcept { +} + +FileMetadata::FileMetadata() noexcept + : type(1), + version(1) { +} + +void FileMetadata::__set_type(const int8_t val) { + this->type = val; +} + +void FileMetadata::__set_version(const int8_t val) { + this->version = val; +} + +void FileMetadata::__set_data(const std::vector & val) { + this->data = val; +} +std::ostream& operator<<(std::ostream& out, const FileMetadata& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t FileMetadata::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_BYTE) { + xfer += iprot->readByte(this->type); + this->__isset.type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_BYTE) { + xfer += iprot->readByte(this->version); + this->__isset.version = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->data.clear(); + uint32_t _size382; + ::apache::thrift::protocol::TType _etype385; + xfer += iprot->readListBegin(_etype385, _size382); + this->data.resize(_size382); + uint32_t _i386; + for (_i386 = 0; _i386 < _size382; ++_i386) + { + xfer += iprot->readBinary(this->data[_i386]); + } + xfer += iprot->readListEnd(); + } + this->__isset.data = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FileMetadata::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FileMetadata"); + + xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_BYTE, 1); + xfer += oprot->writeByte(this->type); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("version", ::apache::thrift::protocol::T_BYTE, 2); + xfer += oprot->writeByte(this->version); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("data", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->data.size())); + std::vector ::const_iterator _iter387; + for (_iter387 = this->data.begin(); _iter387 != this->data.end(); ++_iter387) + { + xfer += oprot->writeBinary((*_iter387)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(FileMetadata &a, FileMetadata &b) noexcept { + using ::std::swap; + swap(a.type, b.type); + swap(a.version, b.version); + swap(a.data, b.data); + swap(a.__isset, b.__isset); +} + +bool FileMetadata::operator==(const FileMetadata & rhs) const +{ + if (!(type == rhs.type)) + return false; + if (!(version == rhs.version)) + return false; + if (!(data == rhs.data)) + return false; + return true; +} + +FileMetadata::FileMetadata(const FileMetadata& other388) { + type = other388.type; + version = other388.version; + data = other388.data; + __isset = other388.__isset; +} +FileMetadata& FileMetadata::operator=(const FileMetadata& other389) { + type = other389.type; + version = other389.version; + data = other389.data; + __isset = other389.__isset; + return *this; +} +void FileMetadata::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "FileMetadata("; + out << "type=" << to_string(type); + out << ", " << "version=" << to_string(version); + out << ", " << "data=" << to_string(data); + out << ")"; +} + + +ObjectDictionary::~ObjectDictionary() noexcept { +} + +ObjectDictionary::ObjectDictionary() noexcept { +} + +void ObjectDictionary::__set_values(const std::map > & val) { + this->values = val; +} +std::ostream& operator<<(std::ostream& out, const ObjectDictionary& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ObjectDictionary::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_values = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->values.clear(); + uint32_t _size390; + ::apache::thrift::protocol::TType _ktype391; + ::apache::thrift::protocol::TType _vtype392; + xfer += iprot->readMapBegin(_ktype391, _vtype392, _size390); + uint32_t _i394; + for (_i394 = 0; _i394 < _size390; ++_i394) + { + std::string _key395; + xfer += iprot->readString(_key395); + std::vector & _val396 = this->values[_key395]; + { + _val396.clear(); + uint32_t _size397; + ::apache::thrift::protocol::TType _etype400; + xfer += iprot->readListBegin(_etype400, _size397); + _val396.resize(_size397); + uint32_t _i401; + for (_i401 = 0; _i401 < _size397; ++_i401) + { + xfer += iprot->readBinary(_val396[_i401]); + } + xfer += iprot->readListEnd(); + } + } + xfer += iprot->readMapEnd(); + } + isset_values = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_values) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ObjectDictionary::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ObjectDictionary"); + + xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_MAP, 1); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast(this->values.size())); + std::map > ::const_iterator _iter402; + for (_iter402 = this->values.begin(); _iter402 != this->values.end(); ++_iter402) + { + xfer += oprot->writeString(_iter402->first); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(_iter402->second.size())); + std::vector ::const_iterator _iter403; + for (_iter403 = _iter402->second.begin(); _iter403 != _iter402->second.end(); ++_iter403) + { + xfer += oprot->writeBinary((*_iter403)); + } + xfer += oprot->writeListEnd(); + } + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ObjectDictionary &a, ObjectDictionary &b) noexcept { + using ::std::swap; + swap(a.values, b.values); +} + +bool ObjectDictionary::operator==(const ObjectDictionary & rhs) const +{ + if (!(values == rhs.values)) + return false; + return true; +} + +ObjectDictionary::ObjectDictionary(const ObjectDictionary& other404) { + values = other404.values; +} +ObjectDictionary& ObjectDictionary::operator=(const ObjectDictionary& other405) { + values = other405.values; + return *this; +} +void ObjectDictionary::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ObjectDictionary("; + out << "values=" << to_string(values); + out << ")"; +} + + +Table::~Table() noexcept { +} + +Table::Table() noexcept + : tableName(), + dbName(), + owner(), + createTime(0), + lastAccessTime(0), + retention(0), + viewOriginalText(), + viewExpandedText(), + tableType(), + temporary(false), + rewriteEnabled(0), + catName(), + ownerType(static_cast(1)), + writeId(-1LL), + isStatsCompliant(0), + accessType(0), + id(0), + txnId(0) { +} + +void Table::__set_tableName(const std::string& val) { + this->tableName = val; +} + +void Table::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void Table::__set_owner(const std::string& val) { + this->owner = val; +} + +void Table::__set_createTime(const int32_t val) { + this->createTime = val; +} + +void Table::__set_lastAccessTime(const int32_t val) { + this->lastAccessTime = val; +} + +void Table::__set_retention(const int32_t val) { + this->retention = val; +} + +void Table::__set_sd(const StorageDescriptor& val) { + this->sd = val; +} + +void Table::__set_partitionKeys(const std::vector & val) { + this->partitionKeys = val; +} + +void Table::__set_parameters(const std::map & val) { + this->parameters = val; +} + +void Table::__set_viewOriginalText(const std::string& val) { + this->viewOriginalText = val; +} + +void Table::__set_viewExpandedText(const std::string& val) { + this->viewExpandedText = val; +} + +void Table::__set_tableType(const std::string& val) { + this->tableType = val; +} + +void Table::__set_privileges(const PrincipalPrivilegeSet& val) { + this->privileges = val; +__isset.privileges = true; +} + +void Table::__set_temporary(const bool val) { + this->temporary = val; +__isset.temporary = true; +} + +void Table::__set_rewriteEnabled(const bool val) { + this->rewriteEnabled = val; +__isset.rewriteEnabled = true; +} + +void Table::__set_creationMetadata(const CreationMetadata& val) { + this->creationMetadata = val; +__isset.creationMetadata = true; +} + +void Table::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void Table::__set_ownerType(const PrincipalType::type val) { + this->ownerType = val; +__isset.ownerType = true; +} + +void Table::__set_writeId(const int64_t val) { + this->writeId = val; +__isset.writeId = true; +} + +void Table::__set_isStatsCompliant(const bool val) { + this->isStatsCompliant = val; +__isset.isStatsCompliant = true; +} + +void Table::__set_colStats(const ColumnStatistics& val) { + this->colStats = val; +__isset.colStats = true; +} + +void Table::__set_accessType(const int8_t val) { + this->accessType = val; +__isset.accessType = true; +} + +void Table::__set_requiredReadCapabilities(const std::vector & val) { + this->requiredReadCapabilities = val; +__isset.requiredReadCapabilities = true; +} + +void Table::__set_requiredWriteCapabilities(const std::vector & val) { + this->requiredWriteCapabilities = val; +__isset.requiredWriteCapabilities = true; +} + +void Table::__set_id(const int64_t val) { + this->id = val; +__isset.id = true; +} + +void Table::__set_fileMetadata(const FileMetadata& val) { + this->fileMetadata = val; +__isset.fileMetadata = true; +} + +void Table::__set_dictionary(const ObjectDictionary& val) { + this->dictionary = val; +__isset.dictionary = true; +} + +void Table::__set_txnId(const int64_t val) { + this->txnId = val; +__isset.txnId = true; +} +std::ostream& operator<<(std::ostream& out, const Table& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + this->__isset.tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->owner); + this->__isset.owner = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->createTime); + this->__isset.createTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->lastAccessTime); + this->__isset.lastAccessTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->retention); + this->__isset.retention = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->sd.read(iprot); + this->__isset.sd = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitionKeys.clear(); + uint32_t _size406; + ::apache::thrift::protocol::TType _etype409; + xfer += iprot->readListBegin(_etype409, _size406); + this->partitionKeys.resize(_size406); + uint32_t _i410; + for (_i410 = 0; _i410 < _size406; ++_i410) + { + xfer += this->partitionKeys[_i410].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.partitionKeys = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->parameters.clear(); + uint32_t _size411; + ::apache::thrift::protocol::TType _ktype412; + ::apache::thrift::protocol::TType _vtype413; + xfer += iprot->readMapBegin(_ktype412, _vtype413, _size411); + uint32_t _i415; + for (_i415 = 0; _i415 < _size411; ++_i415) + { + std::string _key416; + xfer += iprot->readString(_key416); + std::string& _val417 = this->parameters[_key416]; + xfer += iprot->readString(_val417); + } + xfer += iprot->readMapEnd(); + } + this->__isset.parameters = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->viewOriginalText); + this->__isset.viewOriginalText = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 11: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->viewExpandedText); + this->__isset.viewExpandedText = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 12: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableType); + this->__isset.tableType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 13: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->privileges.read(iprot); + this->__isset.privileges = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 14: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->temporary); + this->__isset.temporary = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 15: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->rewriteEnabled); + this->__isset.rewriteEnabled = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 16: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->creationMetadata.read(iprot); + this->__isset.creationMetadata = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 17: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 18: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast418; + xfer += iprot->readI32(ecast418); + this->ownerType = static_cast(ecast418); + this->__isset.ownerType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 19: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->writeId); + this->__isset.writeId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 20: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isStatsCompliant); + this->__isset.isStatsCompliant = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 21: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->colStats.read(iprot); + this->__isset.colStats = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 22: + if (ftype == ::apache::thrift::protocol::T_BYTE) { + xfer += iprot->readByte(this->accessType); + this->__isset.accessType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 23: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->requiredReadCapabilities.clear(); + uint32_t _size419; + ::apache::thrift::protocol::TType _etype422; + xfer += iprot->readListBegin(_etype422, _size419); + this->requiredReadCapabilities.resize(_size419); + uint32_t _i423; + for (_i423 = 0; _i423 < _size419; ++_i423) + { + xfer += iprot->readString(this->requiredReadCapabilities[_i423]); + } + xfer += iprot->readListEnd(); + } + this->__isset.requiredReadCapabilities = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 24: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->requiredWriteCapabilities.clear(); + uint32_t _size424; + ::apache::thrift::protocol::TType _etype427; + xfer += iprot->readListBegin(_etype427, _size424); + this->requiredWriteCapabilities.resize(_size424); + uint32_t _i428; + for (_i428 = 0; _i428 < _size424; ++_i428) + { + xfer += iprot->readString(this->requiredWriteCapabilities[_i428]); + } + xfer += iprot->readListEnd(); + } + this->__isset.requiredWriteCapabilities = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 25: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->id); + this->__isset.id = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 26: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->fileMetadata.read(iprot); + this->__isset.fileMetadata = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 27: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->dictionary.read(iprot); + this->__isset.dictionary = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 28: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnId); + this->__isset.txnId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Table"); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("owner", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->owner); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("createTime", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32(this->createTime); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("lastAccessTime", ::apache::thrift::protocol::T_I32, 5); + xfer += oprot->writeI32(this->lastAccessTime); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("retention", ::apache::thrift::protocol::T_I32, 6); + xfer += oprot->writeI32(this->retention); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("sd", ::apache::thrift::protocol::T_STRUCT, 7); + xfer += this->sd.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("partitionKeys", ::apache::thrift::protocol::T_LIST, 8); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionKeys.size())); + std::vector ::const_iterator _iter429; + for (_iter429 = this->partitionKeys.begin(); _iter429 != this->partitionKeys.end(); ++_iter429) + { + xfer += (*_iter429).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 9); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); + std::map ::const_iterator _iter430; + for (_iter430 = this->parameters.begin(); _iter430 != this->parameters.end(); ++_iter430) + { + xfer += oprot->writeString(_iter430->first); + xfer += oprot->writeString(_iter430->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("viewOriginalText", ::apache::thrift::protocol::T_STRING, 10); + xfer += oprot->writeString(this->viewOriginalText); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("viewExpandedText", ::apache::thrift::protocol::T_STRING, 11); + xfer += oprot->writeString(this->viewExpandedText); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableType", ::apache::thrift::protocol::T_STRING, 12); + xfer += oprot->writeString(this->tableType); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.privileges) { + xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_STRUCT, 13); + xfer += this->privileges.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.temporary) { + xfer += oprot->writeFieldBegin("temporary", ::apache::thrift::protocol::T_BOOL, 14); + xfer += oprot->writeBool(this->temporary); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.rewriteEnabled) { + xfer += oprot->writeFieldBegin("rewriteEnabled", ::apache::thrift::protocol::T_BOOL, 15); + xfer += oprot->writeBool(this->rewriteEnabled); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.creationMetadata) { + xfer += oprot->writeFieldBegin("creationMetadata", ::apache::thrift::protocol::T_STRUCT, 16); + xfer += this->creationMetadata.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 17); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ownerType) { + xfer += oprot->writeFieldBegin("ownerType", ::apache::thrift::protocol::T_I32, 18); + xfer += oprot->writeI32(static_cast(this->ownerType)); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.writeId) { + xfer += oprot->writeFieldBegin("writeId", ::apache::thrift::protocol::T_I64, 19); + xfer += oprot->writeI64(this->writeId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.isStatsCompliant) { + xfer += oprot->writeFieldBegin("isStatsCompliant", ::apache::thrift::protocol::T_BOOL, 20); + xfer += oprot->writeBool(this->isStatsCompliant); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.colStats) { + xfer += oprot->writeFieldBegin("colStats", ::apache::thrift::protocol::T_STRUCT, 21); + xfer += this->colStats.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.accessType) { + xfer += oprot->writeFieldBegin("accessType", ::apache::thrift::protocol::T_BYTE, 22); + xfer += oprot->writeByte(this->accessType); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.requiredReadCapabilities) { + xfer += oprot->writeFieldBegin("requiredReadCapabilities", ::apache::thrift::protocol::T_LIST, 23); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->requiredReadCapabilities.size())); + std::vector ::const_iterator _iter431; + for (_iter431 = this->requiredReadCapabilities.begin(); _iter431 != this->requiredReadCapabilities.end(); ++_iter431) + { + xfer += oprot->writeString((*_iter431)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.requiredWriteCapabilities) { + xfer += oprot->writeFieldBegin("requiredWriteCapabilities", ::apache::thrift::protocol::T_LIST, 24); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->requiredWriteCapabilities.size())); + std::vector ::const_iterator _iter432; + for (_iter432 = this->requiredWriteCapabilities.begin(); _iter432 != this->requiredWriteCapabilities.end(); ++_iter432) + { + xfer += oprot->writeString((*_iter432)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.id) { + xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I64, 25); + xfer += oprot->writeI64(this->id); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.fileMetadata) { + xfer += oprot->writeFieldBegin("fileMetadata", ::apache::thrift::protocol::T_STRUCT, 26); + xfer += this->fileMetadata.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.dictionary) { + xfer += oprot->writeFieldBegin("dictionary", ::apache::thrift::protocol::T_STRUCT, 27); + xfer += this->dictionary.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.txnId) { + xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 28); + xfer += oprot->writeI64(this->txnId); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Table &a, Table &b) noexcept { + using ::std::swap; + swap(a.tableName, b.tableName); + swap(a.dbName, b.dbName); + swap(a.owner, b.owner); + swap(a.createTime, b.createTime); + swap(a.lastAccessTime, b.lastAccessTime); + swap(a.retention, b.retention); + swap(a.sd, b.sd); + swap(a.partitionKeys, b.partitionKeys); + swap(a.parameters, b.parameters); + swap(a.viewOriginalText, b.viewOriginalText); + swap(a.viewExpandedText, b.viewExpandedText); + swap(a.tableType, b.tableType); + swap(a.privileges, b.privileges); + swap(a.temporary, b.temporary); + swap(a.rewriteEnabled, b.rewriteEnabled); + swap(a.creationMetadata, b.creationMetadata); + swap(a.catName, b.catName); + swap(a.ownerType, b.ownerType); + swap(a.writeId, b.writeId); + swap(a.isStatsCompliant, b.isStatsCompliant); + swap(a.colStats, b.colStats); + swap(a.accessType, b.accessType); + swap(a.requiredReadCapabilities, b.requiredReadCapabilities); + swap(a.requiredWriteCapabilities, b.requiredWriteCapabilities); + swap(a.id, b.id); + swap(a.fileMetadata, b.fileMetadata); + swap(a.dictionary, b.dictionary); + swap(a.txnId, b.txnId); + swap(a.__isset, b.__isset); +} + +bool Table::operator==(const Table & rhs) const +{ + if (!(tableName == rhs.tableName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(owner == rhs.owner)) + return false; + if (!(createTime == rhs.createTime)) + return false; + if (!(lastAccessTime == rhs.lastAccessTime)) + return false; + if (!(retention == rhs.retention)) + return false; + if (!(sd == rhs.sd)) + return false; + if (!(partitionKeys == rhs.partitionKeys)) + return false; + if (!(parameters == rhs.parameters)) + return false; + if (!(viewOriginalText == rhs.viewOriginalText)) + return false; + if (!(viewExpandedText == rhs.viewExpandedText)) + return false; + if (!(tableType == rhs.tableType)) + return false; + if (__isset.privileges != rhs.__isset.privileges) + return false; + else if (__isset.privileges && !(privileges == rhs.privileges)) + return false; + if (__isset.temporary != rhs.__isset.temporary) + return false; + else if (__isset.temporary && !(temporary == rhs.temporary)) + return false; + if (__isset.rewriteEnabled != rhs.__isset.rewriteEnabled) + return false; + else if (__isset.rewriteEnabled && !(rewriteEnabled == rhs.rewriteEnabled)) + return false; + if (__isset.creationMetadata != rhs.__isset.creationMetadata) + return false; + else if (__isset.creationMetadata && !(creationMetadata == rhs.creationMetadata)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (__isset.ownerType != rhs.__isset.ownerType) + return false; + else if (__isset.ownerType && !(ownerType == rhs.ownerType)) + return false; + if (__isset.writeId != rhs.__isset.writeId) + return false; + else if (__isset.writeId && !(writeId == rhs.writeId)) + return false; + if (__isset.isStatsCompliant != rhs.__isset.isStatsCompliant) + return false; + else if (__isset.isStatsCompliant && !(isStatsCompliant == rhs.isStatsCompliant)) + return false; + if (__isset.colStats != rhs.__isset.colStats) + return false; + else if (__isset.colStats && !(colStats == rhs.colStats)) + return false; + if (__isset.accessType != rhs.__isset.accessType) + return false; + else if (__isset.accessType && !(accessType == rhs.accessType)) + return false; + if (__isset.requiredReadCapabilities != rhs.__isset.requiredReadCapabilities) + return false; + else if (__isset.requiredReadCapabilities && !(requiredReadCapabilities == rhs.requiredReadCapabilities)) + return false; + if (__isset.requiredWriteCapabilities != rhs.__isset.requiredWriteCapabilities) + return false; + else if (__isset.requiredWriteCapabilities && !(requiredWriteCapabilities == rhs.requiredWriteCapabilities)) + return false; + if (__isset.id != rhs.__isset.id) + return false; + else if (__isset.id && !(id == rhs.id)) + return false; + if (__isset.fileMetadata != rhs.__isset.fileMetadata) + return false; + else if (__isset.fileMetadata && !(fileMetadata == rhs.fileMetadata)) + return false; + if (__isset.dictionary != rhs.__isset.dictionary) + return false; + else if (__isset.dictionary && !(dictionary == rhs.dictionary)) + return false; + if (__isset.txnId != rhs.__isset.txnId) + return false; + else if (__isset.txnId && !(txnId == rhs.txnId)) + return false; + return true; +} + +Table::Table(const Table& other433) { + tableName = other433.tableName; + dbName = other433.dbName; + owner = other433.owner; + createTime = other433.createTime; + lastAccessTime = other433.lastAccessTime; + retention = other433.retention; + sd = other433.sd; + partitionKeys = other433.partitionKeys; + parameters = other433.parameters; + viewOriginalText = other433.viewOriginalText; + viewExpandedText = other433.viewExpandedText; + tableType = other433.tableType; + privileges = other433.privileges; + temporary = other433.temporary; + rewriteEnabled = other433.rewriteEnabled; + creationMetadata = other433.creationMetadata; + catName = other433.catName; + ownerType = other433.ownerType; + writeId = other433.writeId; + isStatsCompliant = other433.isStatsCompliant; + colStats = other433.colStats; + accessType = other433.accessType; + requiredReadCapabilities = other433.requiredReadCapabilities; + requiredWriteCapabilities = other433.requiredWriteCapabilities; + id = other433.id; + fileMetadata = other433.fileMetadata; + dictionary = other433.dictionary; + txnId = other433.txnId; + __isset = other433.__isset; +} +Table& Table::operator=(const Table& other434) { + tableName = other434.tableName; + dbName = other434.dbName; + owner = other434.owner; + createTime = other434.createTime; + lastAccessTime = other434.lastAccessTime; + retention = other434.retention; + sd = other434.sd; + partitionKeys = other434.partitionKeys; + parameters = other434.parameters; + viewOriginalText = other434.viewOriginalText; + viewExpandedText = other434.viewExpandedText; + tableType = other434.tableType; + privileges = other434.privileges; + temporary = other434.temporary; + rewriteEnabled = other434.rewriteEnabled; + creationMetadata = other434.creationMetadata; + catName = other434.catName; + ownerType = other434.ownerType; + writeId = other434.writeId; + isStatsCompliant = other434.isStatsCompliant; + colStats = other434.colStats; + accessType = other434.accessType; + requiredReadCapabilities = other434.requiredReadCapabilities; + requiredWriteCapabilities = other434.requiredWriteCapabilities; + id = other434.id; + fileMetadata = other434.fileMetadata; + dictionary = other434.dictionary; + txnId = other434.txnId; + __isset = other434.__isset; + return *this; +} +void Table::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Table("; + out << "tableName=" << to_string(tableName); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "owner=" << to_string(owner); + out << ", " << "createTime=" << to_string(createTime); + out << ", " << "lastAccessTime=" << to_string(lastAccessTime); + out << ", " << "retention=" << to_string(retention); + out << ", " << "sd=" << to_string(sd); + out << ", " << "partitionKeys=" << to_string(partitionKeys); + out << ", " << "parameters=" << to_string(parameters); + out << ", " << "viewOriginalText=" << to_string(viewOriginalText); + out << ", " << "viewExpandedText=" << to_string(viewExpandedText); + out << ", " << "tableType=" << to_string(tableType); + out << ", " << "privileges="; (__isset.privileges ? (out << to_string(privileges)) : (out << "")); + out << ", " << "temporary="; (__isset.temporary ? (out << to_string(temporary)) : (out << "")); + out << ", " << "rewriteEnabled="; (__isset.rewriteEnabled ? (out << to_string(rewriteEnabled)) : (out << "")); + out << ", " << "creationMetadata="; (__isset.creationMetadata ? (out << to_string(creationMetadata)) : (out << "")); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "ownerType="; (__isset.ownerType ? (out << to_string(ownerType)) : (out << "")); + out << ", " << "writeId="; (__isset.writeId ? (out << to_string(writeId)) : (out << "")); + out << ", " << "isStatsCompliant="; (__isset.isStatsCompliant ? (out << to_string(isStatsCompliant)) : (out << "")); + out << ", " << "colStats="; (__isset.colStats ? (out << to_string(colStats)) : (out << "")); + out << ", " << "accessType="; (__isset.accessType ? (out << to_string(accessType)) : (out << "")); + out << ", " << "requiredReadCapabilities="; (__isset.requiredReadCapabilities ? (out << to_string(requiredReadCapabilities)) : (out << "")); + out << ", " << "requiredWriteCapabilities="; (__isset.requiredWriteCapabilities ? (out << to_string(requiredWriteCapabilities)) : (out << "")); + out << ", " << "id="; (__isset.id ? (out << to_string(id)) : (out << "")); + out << ", " << "fileMetadata="; (__isset.fileMetadata ? (out << to_string(fileMetadata)) : (out << "")); + out << ", " << "dictionary="; (__isset.dictionary ? (out << to_string(dictionary)) : (out << "")); + out << ", " << "txnId="; (__isset.txnId ? (out << to_string(txnId)) : (out << "")); + out << ")"; +} + + +SourceTable::~SourceTable() noexcept { +} + +SourceTable::SourceTable() noexcept + : insertedCount(0), + updatedCount(0), + deletedCount(0) { +} + +void SourceTable::__set_table(const Table& val) { + this->table = val; +} + +void SourceTable::__set_insertedCount(const int64_t val) { + this->insertedCount = val; +} + +void SourceTable::__set_updatedCount(const int64_t val) { + this->updatedCount = val; +} + +void SourceTable::__set_deletedCount(const int64_t val) { + this->deletedCount = val; +} +std::ostream& operator<<(std::ostream& out, const SourceTable& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t SourceTable::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_table = false; + bool isset_insertedCount = false; + bool isset_updatedCount = false; + bool isset_deletedCount = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->table.read(iprot); + isset_table = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->insertedCount); + isset_insertedCount = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->updatedCount); + isset_updatedCount = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->deletedCount); + isset_deletedCount = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_table) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_insertedCount) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_updatedCount) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_deletedCount) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t SourceTable::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("SourceTable"); + + xfer += oprot->writeFieldBegin("table", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->table.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("insertedCount", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->insertedCount); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("updatedCount", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->updatedCount); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deletedCount", ::apache::thrift::protocol::T_I64, 4); + xfer += oprot->writeI64(this->deletedCount); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(SourceTable &a, SourceTable &b) noexcept { + using ::std::swap; + swap(a.table, b.table); + swap(a.insertedCount, b.insertedCount); + swap(a.updatedCount, b.updatedCount); + swap(a.deletedCount, b.deletedCount); +} + +bool SourceTable::operator==(const SourceTable & rhs) const +{ + if (!(table == rhs.table)) + return false; + if (!(insertedCount == rhs.insertedCount)) + return false; + if (!(updatedCount == rhs.updatedCount)) + return false; + if (!(deletedCount == rhs.deletedCount)) + return false; + return true; +} + +SourceTable::SourceTable(const SourceTable& other435) { + table = other435.table; + insertedCount = other435.insertedCount; + updatedCount = other435.updatedCount; + deletedCount = other435.deletedCount; +} +SourceTable& SourceTable::operator=(const SourceTable& other436) { + table = other436.table; + insertedCount = other436.insertedCount; + updatedCount = other436.updatedCount; + deletedCount = other436.deletedCount; + return *this; +} +void SourceTable::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "SourceTable("; + out << "table=" << to_string(table); + out << ", " << "insertedCount=" << to_string(insertedCount); + out << ", " << "updatedCount=" << to_string(updatedCount); + out << ", " << "deletedCount=" << to_string(deletedCount); + out << ")"; +} + + +Partition::~Partition() noexcept { +} + +Partition::Partition() noexcept + : dbName(), + tableName(), + createTime(0), + lastAccessTime(0), + catName(), + writeId(-1LL), + isStatsCompliant(0) { +} + +void Partition::__set_values(const std::vector & val) { + this->values = val; +} + +void Partition::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void Partition::__set_tableName(const std::string& val) { + this->tableName = val; +} + +void Partition::__set_createTime(const int32_t val) { + this->createTime = val; +} + +void Partition::__set_lastAccessTime(const int32_t val) { + this->lastAccessTime = val; +} + +void Partition::__set_sd(const StorageDescriptor& val) { + this->sd = val; +} + +void Partition::__set_parameters(const std::map & val) { + this->parameters = val; +} + +void Partition::__set_privileges(const PrincipalPrivilegeSet& val) { + this->privileges = val; +__isset.privileges = true; +} + +void Partition::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void Partition::__set_writeId(const int64_t val) { + this->writeId = val; +__isset.writeId = true; +} + +void Partition::__set_isStatsCompliant(const bool val) { + this->isStatsCompliant = val; +__isset.isStatsCompliant = true; +} + +void Partition::__set_colStats(const ColumnStatistics& val) { + this->colStats = val; +__isset.colStats = true; +} + +void Partition::__set_fileMetadata(const FileMetadata& val) { + this->fileMetadata = val; +__isset.fileMetadata = true; +} +std::ostream& operator<<(std::ostream& out, const Partition& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->values.clear(); + uint32_t _size437; + ::apache::thrift::protocol::TType _etype440; + xfer += iprot->readListBegin(_etype440, _size437); + this->values.resize(_size437); + uint32_t _i441; + for (_i441 = 0; _i441 < _size437; ++_i441) + { + xfer += iprot->readString(this->values[_i441]); + } + xfer += iprot->readListEnd(); + } + this->__isset.values = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + this->__isset.tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->createTime); + this->__isset.createTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->lastAccessTime); + this->__isset.lastAccessTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->sd.read(iprot); + this->__isset.sd = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->parameters.clear(); + uint32_t _size442; + ::apache::thrift::protocol::TType _ktype443; + ::apache::thrift::protocol::TType _vtype444; + xfer += iprot->readMapBegin(_ktype443, _vtype444, _size442); + uint32_t _i446; + for (_i446 = 0; _i446 < _size442; ++_i446) + { + std::string _key447; + xfer += iprot->readString(_key447); + std::string& _val448 = this->parameters[_key447]; + xfer += iprot->readString(_val448); + } + xfer += iprot->readMapEnd(); + } + this->__isset.parameters = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->privileges.read(iprot); + this->__isset.privileges = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->writeId); + this->__isset.writeId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 11: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isStatsCompliant); + this->__isset.isStatsCompliant = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 12: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->colStats.read(iprot); + this->__isset.colStats = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 13: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->fileMetadata.read(iprot); + this->__isset.fileMetadata = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Partition::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Partition"); + + xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->values.size())); + std::vector ::const_iterator _iter449; + for (_iter449 = this->values.begin(); _iter449 != this->values.end(); ++_iter449) + { + xfer += oprot->writeString((*_iter449)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("createTime", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32(this->createTime); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("lastAccessTime", ::apache::thrift::protocol::T_I32, 5); + xfer += oprot->writeI32(this->lastAccessTime); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("sd", ::apache::thrift::protocol::T_STRUCT, 6); + xfer += this->sd.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 7); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); + std::map ::const_iterator _iter450; + for (_iter450 = this->parameters.begin(); _iter450 != this->parameters.end(); ++_iter450) + { + xfer += oprot->writeString(_iter450->first); + xfer += oprot->writeString(_iter450->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.privileges) { + xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_STRUCT, 8); + xfer += this->privileges.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 9); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.writeId) { + xfer += oprot->writeFieldBegin("writeId", ::apache::thrift::protocol::T_I64, 10); + xfer += oprot->writeI64(this->writeId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.isStatsCompliant) { + xfer += oprot->writeFieldBegin("isStatsCompliant", ::apache::thrift::protocol::T_BOOL, 11); + xfer += oprot->writeBool(this->isStatsCompliant); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.colStats) { + xfer += oprot->writeFieldBegin("colStats", ::apache::thrift::protocol::T_STRUCT, 12); + xfer += this->colStats.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.fileMetadata) { + xfer += oprot->writeFieldBegin("fileMetadata", ::apache::thrift::protocol::T_STRUCT, 13); + xfer += this->fileMetadata.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Partition &a, Partition &b) noexcept { + using ::std::swap; + swap(a.values, b.values); + swap(a.dbName, b.dbName); + swap(a.tableName, b.tableName); + swap(a.createTime, b.createTime); + swap(a.lastAccessTime, b.lastAccessTime); + swap(a.sd, b.sd); + swap(a.parameters, b.parameters); + swap(a.privileges, b.privileges); + swap(a.catName, b.catName); + swap(a.writeId, b.writeId); + swap(a.isStatsCompliant, b.isStatsCompliant); + swap(a.colStats, b.colStats); + swap(a.fileMetadata, b.fileMetadata); + swap(a.__isset, b.__isset); +} + +bool Partition::operator==(const Partition & rhs) const +{ + if (!(values == rhs.values)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(createTime == rhs.createTime)) + return false; + if (!(lastAccessTime == rhs.lastAccessTime)) + return false; + if (!(sd == rhs.sd)) + return false; + if (!(parameters == rhs.parameters)) + return false; + if (__isset.privileges != rhs.__isset.privileges) + return false; + else if (__isset.privileges && !(privileges == rhs.privileges)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (__isset.writeId != rhs.__isset.writeId) + return false; + else if (__isset.writeId && !(writeId == rhs.writeId)) + return false; + if (__isset.isStatsCompliant != rhs.__isset.isStatsCompliant) + return false; + else if (__isset.isStatsCompliant && !(isStatsCompliant == rhs.isStatsCompliant)) + return false; + if (__isset.colStats != rhs.__isset.colStats) + return false; + else if (__isset.colStats && !(colStats == rhs.colStats)) + return false; + if (__isset.fileMetadata != rhs.__isset.fileMetadata) + return false; + else if (__isset.fileMetadata && !(fileMetadata == rhs.fileMetadata)) + return false; + return true; +} + +Partition::Partition(const Partition& other451) { + values = other451.values; + dbName = other451.dbName; + tableName = other451.tableName; + createTime = other451.createTime; + lastAccessTime = other451.lastAccessTime; + sd = other451.sd; + parameters = other451.parameters; + privileges = other451.privileges; + catName = other451.catName; + writeId = other451.writeId; + isStatsCompliant = other451.isStatsCompliant; + colStats = other451.colStats; + fileMetadata = other451.fileMetadata; + __isset = other451.__isset; +} +Partition& Partition::operator=(const Partition& other452) { + values = other452.values; + dbName = other452.dbName; + tableName = other452.tableName; + createTime = other452.createTime; + lastAccessTime = other452.lastAccessTime; + sd = other452.sd; + parameters = other452.parameters; + privileges = other452.privileges; + catName = other452.catName; + writeId = other452.writeId; + isStatsCompliant = other452.isStatsCompliant; + colStats = other452.colStats; + fileMetadata = other452.fileMetadata; + __isset = other452.__isset; + return *this; +} +void Partition::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Partition("; + out << "values=" << to_string(values); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "tableName=" << to_string(tableName); + out << ", " << "createTime=" << to_string(createTime); + out << ", " << "lastAccessTime=" << to_string(lastAccessTime); + out << ", " << "sd=" << to_string(sd); + out << ", " << "parameters=" << to_string(parameters); + out << ", " << "privileges="; (__isset.privileges ? (out << to_string(privileges)) : (out << "")); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "writeId="; (__isset.writeId ? (out << to_string(writeId)) : (out << "")); + out << ", " << "isStatsCompliant="; (__isset.isStatsCompliant ? (out << to_string(isStatsCompliant)) : (out << "")); + out << ", " << "colStats="; (__isset.colStats ? (out << to_string(colStats)) : (out << "")); + out << ", " << "fileMetadata="; (__isset.fileMetadata ? (out << to_string(fileMetadata)) : (out << "")); + out << ")"; +} + + +PartitionWithoutSD::~PartitionWithoutSD() noexcept { +} + +PartitionWithoutSD::PartitionWithoutSD() noexcept + : createTime(0), + lastAccessTime(0), + relativePath() { +} + +void PartitionWithoutSD::__set_values(const std::vector & val) { + this->values = val; +} + +void PartitionWithoutSD::__set_createTime(const int32_t val) { + this->createTime = val; +} + +void PartitionWithoutSD::__set_lastAccessTime(const int32_t val) { + this->lastAccessTime = val; +} + +void PartitionWithoutSD::__set_relativePath(const std::string& val) { + this->relativePath = val; +} + +void PartitionWithoutSD::__set_parameters(const std::map & val) { + this->parameters = val; +} + +void PartitionWithoutSD::__set_privileges(const PrincipalPrivilegeSet& val) { + this->privileges = val; +__isset.privileges = true; +} +std::ostream& operator<<(std::ostream& out, const PartitionWithoutSD& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->values.clear(); + uint32_t _size453; + ::apache::thrift::protocol::TType _etype456; + xfer += iprot->readListBegin(_etype456, _size453); + this->values.resize(_size453); + uint32_t _i457; + for (_i457 = 0; _i457 < _size453; ++_i457) + { + xfer += iprot->readString(this->values[_i457]); + } + xfer += iprot->readListEnd(); + } + this->__isset.values = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->createTime); + this->__isset.createTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->lastAccessTime); + this->__isset.lastAccessTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->relativePath); + this->__isset.relativePath = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->parameters.clear(); + uint32_t _size458; + ::apache::thrift::protocol::TType _ktype459; + ::apache::thrift::protocol::TType _vtype460; + xfer += iprot->readMapBegin(_ktype459, _vtype460, _size458); + uint32_t _i462; + for (_i462 = 0; _i462 < _size458; ++_i462) + { + std::string _key463; + xfer += iprot->readString(_key463); + std::string& _val464 = this->parameters[_key463]; + xfer += iprot->readString(_val464); + } + xfer += iprot->readMapEnd(); + } + this->__isset.parameters = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->privileges.read(iprot); + this->__isset.privileges = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t PartitionWithoutSD::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PartitionWithoutSD"); + + xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->values.size())); + std::vector ::const_iterator _iter465; + for (_iter465 = this->values.begin(); _iter465 != this->values.end(); ++_iter465) + { + xfer += oprot->writeString((*_iter465)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("createTime", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(this->createTime); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("lastAccessTime", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32(this->lastAccessTime); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("relativePath", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->relativePath); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 5); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); + std::map ::const_iterator _iter466; + for (_iter466 = this->parameters.begin(); _iter466 != this->parameters.end(); ++_iter466) + { + xfer += oprot->writeString(_iter466->first); + xfer += oprot->writeString(_iter466->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.privileges) { + xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_STRUCT, 6); + xfer += this->privileges.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PartitionWithoutSD &a, PartitionWithoutSD &b) noexcept { + using ::std::swap; + swap(a.values, b.values); + swap(a.createTime, b.createTime); + swap(a.lastAccessTime, b.lastAccessTime); + swap(a.relativePath, b.relativePath); + swap(a.parameters, b.parameters); + swap(a.privileges, b.privileges); + swap(a.__isset, b.__isset); +} + +bool PartitionWithoutSD::operator==(const PartitionWithoutSD & rhs) const +{ + if (!(values == rhs.values)) + return false; + if (!(createTime == rhs.createTime)) + return false; + if (!(lastAccessTime == rhs.lastAccessTime)) + return false; + if (!(relativePath == rhs.relativePath)) + return false; + if (!(parameters == rhs.parameters)) + return false; + if (__isset.privileges != rhs.__isset.privileges) + return false; + else if (__isset.privileges && !(privileges == rhs.privileges)) + return false; + return true; +} + +PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other467) { + values = other467.values; + createTime = other467.createTime; + lastAccessTime = other467.lastAccessTime; + relativePath = other467.relativePath; + parameters = other467.parameters; + privileges = other467.privileges; + __isset = other467.__isset; +} +PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other468) { + values = other468.values; + createTime = other468.createTime; + lastAccessTime = other468.lastAccessTime; + relativePath = other468.relativePath; + parameters = other468.parameters; + privileges = other468.privileges; + __isset = other468.__isset; + return *this; +} +void PartitionWithoutSD::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PartitionWithoutSD("; + out << "values=" << to_string(values); + out << ", " << "createTime=" << to_string(createTime); + out << ", " << "lastAccessTime=" << to_string(lastAccessTime); + out << ", " << "relativePath=" << to_string(relativePath); + out << ", " << "parameters=" << to_string(parameters); + out << ", " << "privileges="; (__isset.privileges ? (out << to_string(privileges)) : (out << "")); + out << ")"; +} + + +PartitionSpecWithSharedSD::~PartitionSpecWithSharedSD() noexcept { +} + +PartitionSpecWithSharedSD::PartitionSpecWithSharedSD() noexcept { +} + +void PartitionSpecWithSharedSD::__set_partitions(const std::vector & val) { + this->partitions = val; +} + +void PartitionSpecWithSharedSD::__set_sd(const StorageDescriptor& val) { + this->sd = val; +} +std::ostream& operator<<(std::ostream& out, const PartitionSpecWithSharedSD& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PartitionSpecWithSharedSD::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitions.clear(); + uint32_t _size469; + ::apache::thrift::protocol::TType _etype472; + xfer += iprot->readListBegin(_etype472, _size469); + this->partitions.resize(_size469); + uint32_t _i473; + for (_i473 = 0; _i473 < _size469; ++_i473) + { + xfer += this->partitions[_i473].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.partitions = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->sd.read(iprot); + this->__isset.sd = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t PartitionSpecWithSharedSD::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PartitionSpecWithSharedSD"); + + xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); + std::vector ::const_iterator _iter474; + for (_iter474 = this->partitions.begin(); _iter474 != this->partitions.end(); ++_iter474) + { + xfer += (*_iter474).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("sd", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->sd.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PartitionSpecWithSharedSD &a, PartitionSpecWithSharedSD &b) noexcept { + using ::std::swap; + swap(a.partitions, b.partitions); + swap(a.sd, b.sd); + swap(a.__isset, b.__isset); +} + +bool PartitionSpecWithSharedSD::operator==(const PartitionSpecWithSharedSD & rhs) const +{ + if (!(partitions == rhs.partitions)) + return false; + if (!(sd == rhs.sd)) + return false; + return true; +} + +PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other475) { + partitions = other475.partitions; + sd = other475.sd; + __isset = other475.__isset; +} +PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other476) { + partitions = other476.partitions; + sd = other476.sd; + __isset = other476.__isset; + return *this; +} +void PartitionSpecWithSharedSD::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PartitionSpecWithSharedSD("; + out << "partitions=" << to_string(partitions); + out << ", " << "sd=" << to_string(sd); + out << ")"; +} + + +PartitionListComposingSpec::~PartitionListComposingSpec() noexcept { +} + +PartitionListComposingSpec::PartitionListComposingSpec() noexcept { +} + +void PartitionListComposingSpec::__set_partitions(const std::vector & val) { + this->partitions = val; +} +std::ostream& operator<<(std::ostream& out, const PartitionListComposingSpec& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PartitionListComposingSpec::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitions.clear(); + uint32_t _size477; + ::apache::thrift::protocol::TType _etype480; + xfer += iprot->readListBegin(_etype480, _size477); + this->partitions.resize(_size477); + uint32_t _i481; + for (_i481 = 0; _i481 < _size477; ++_i481) + { + xfer += this->partitions[_i481].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.partitions = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t PartitionListComposingSpec::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PartitionListComposingSpec"); + + xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); + std::vector ::const_iterator _iter482; + for (_iter482 = this->partitions.begin(); _iter482 != this->partitions.end(); ++_iter482) + { + xfer += (*_iter482).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PartitionListComposingSpec &a, PartitionListComposingSpec &b) noexcept { + using ::std::swap; + swap(a.partitions, b.partitions); + swap(a.__isset, b.__isset); +} + +bool PartitionListComposingSpec::operator==(const PartitionListComposingSpec & rhs) const +{ + if (!(partitions == rhs.partitions)) + return false; + return true; +} + +PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other483) { + partitions = other483.partitions; + __isset = other483.__isset; +} +PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other484) { + partitions = other484.partitions; + __isset = other484.__isset; + return *this; +} +void PartitionListComposingSpec::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PartitionListComposingSpec("; + out << "partitions=" << to_string(partitions); + out << ")"; +} + + +PartitionSpec::~PartitionSpec() noexcept { +} + +PartitionSpec::PartitionSpec() noexcept + : dbName(), + tableName(), + rootPath(), + catName(), + writeId(-1LL), + isStatsCompliant(0) { +} + +void PartitionSpec::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void PartitionSpec::__set_tableName(const std::string& val) { + this->tableName = val; +} + +void PartitionSpec::__set_rootPath(const std::string& val) { + this->rootPath = val; +} + +void PartitionSpec::__set_sharedSDPartitionSpec(const PartitionSpecWithSharedSD& val) { + this->sharedSDPartitionSpec = val; +__isset.sharedSDPartitionSpec = true; +} + +void PartitionSpec::__set_partitionList(const PartitionListComposingSpec& val) { + this->partitionList = val; +__isset.partitionList = true; +} + +void PartitionSpec::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void PartitionSpec::__set_writeId(const int64_t val) { + this->writeId = val; +__isset.writeId = true; +} + +void PartitionSpec::__set_isStatsCompliant(const bool val) { + this->isStatsCompliant = val; +__isset.isStatsCompliant = true; +} +std::ostream& operator<<(std::ostream& out, const PartitionSpec& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PartitionSpec::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + this->__isset.tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->rootPath); + this->__isset.rootPath = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->sharedSDPartitionSpec.read(iprot); + this->__isset.sharedSDPartitionSpec = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->partitionList.read(iprot); + this->__isset.partitionList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->writeId); + this->__isset.writeId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isStatsCompliant); + this->__isset.isStatsCompliant = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t PartitionSpec::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PartitionSpec"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("rootPath", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->rootPath); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.sharedSDPartitionSpec) { + xfer += oprot->writeFieldBegin("sharedSDPartitionSpec", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->sharedSDPartitionSpec.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.partitionList) { + xfer += oprot->writeFieldBegin("partitionList", ::apache::thrift::protocol::T_STRUCT, 5); + xfer += this->partitionList.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.writeId) { + xfer += oprot->writeFieldBegin("writeId", ::apache::thrift::protocol::T_I64, 7); + xfer += oprot->writeI64(this->writeId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.isStatsCompliant) { + xfer += oprot->writeFieldBegin("isStatsCompliant", ::apache::thrift::protocol::T_BOOL, 8); + xfer += oprot->writeBool(this->isStatsCompliant); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PartitionSpec &a, PartitionSpec &b) noexcept { + using ::std::swap; + swap(a.dbName, b.dbName); + swap(a.tableName, b.tableName); + swap(a.rootPath, b.rootPath); + swap(a.sharedSDPartitionSpec, b.sharedSDPartitionSpec); + swap(a.partitionList, b.partitionList); + swap(a.catName, b.catName); + swap(a.writeId, b.writeId); + swap(a.isStatsCompliant, b.isStatsCompliant); + swap(a.__isset, b.__isset); +} + +bool PartitionSpec::operator==(const PartitionSpec & rhs) const +{ + if (!(dbName == rhs.dbName)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(rootPath == rhs.rootPath)) + return false; + if (__isset.sharedSDPartitionSpec != rhs.__isset.sharedSDPartitionSpec) + return false; + else if (__isset.sharedSDPartitionSpec && !(sharedSDPartitionSpec == rhs.sharedSDPartitionSpec)) + return false; + if (__isset.partitionList != rhs.__isset.partitionList) + return false; + else if (__isset.partitionList && !(partitionList == rhs.partitionList)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (__isset.writeId != rhs.__isset.writeId) + return false; + else if (__isset.writeId && !(writeId == rhs.writeId)) + return false; + if (__isset.isStatsCompliant != rhs.__isset.isStatsCompliant) + return false; + else if (__isset.isStatsCompliant && !(isStatsCompliant == rhs.isStatsCompliant)) + return false; + return true; +} + +PartitionSpec::PartitionSpec(const PartitionSpec& other485) { + dbName = other485.dbName; + tableName = other485.tableName; + rootPath = other485.rootPath; + sharedSDPartitionSpec = other485.sharedSDPartitionSpec; + partitionList = other485.partitionList; + catName = other485.catName; + writeId = other485.writeId; + isStatsCompliant = other485.isStatsCompliant; + __isset = other485.__isset; +} +PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other486) { + dbName = other486.dbName; + tableName = other486.tableName; + rootPath = other486.rootPath; + sharedSDPartitionSpec = other486.sharedSDPartitionSpec; + partitionList = other486.partitionList; + catName = other486.catName; + writeId = other486.writeId; + isStatsCompliant = other486.isStatsCompliant; + __isset = other486.__isset; + return *this; +} +void PartitionSpec::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PartitionSpec("; + out << "dbName=" << to_string(dbName); + out << ", " << "tableName=" << to_string(tableName); + out << ", " << "rootPath=" << to_string(rootPath); + out << ", " << "sharedSDPartitionSpec="; (__isset.sharedSDPartitionSpec ? (out << to_string(sharedSDPartitionSpec)) : (out << "")); + out << ", " << "partitionList="; (__isset.partitionList ? (out << to_string(partitionList)) : (out << "")); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "writeId="; (__isset.writeId ? (out << to_string(writeId)) : (out << "")); + out << ", " << "isStatsCompliant="; (__isset.isStatsCompliant ? (out << to_string(isStatsCompliant)) : (out << "")); + out << ")"; +} + + +AggrStats::~AggrStats() noexcept { +} + +AggrStats::AggrStats() noexcept + : partsFound(0), + isStatsCompliant(0) { +} + +void AggrStats::__set_colStats(const std::vector & val) { + this->colStats = val; +} + +void AggrStats::__set_partsFound(const int64_t val) { + this->partsFound = val; +} + +void AggrStats::__set_isStatsCompliant(const bool val) { + this->isStatsCompliant = val; +__isset.isStatsCompliant = true; +} +std::ostream& operator<<(std::ostream& out, const AggrStats& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AggrStats::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_colStats = false; + bool isset_partsFound = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->colStats.clear(); + uint32_t _size487; + ::apache::thrift::protocol::TType _etype490; + xfer += iprot->readListBegin(_etype490, _size487); + this->colStats.resize(_size487); + uint32_t _i491; + for (_i491 = 0; _i491 < _size487; ++_i491) + { + xfer += this->colStats[_i491].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_colStats = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->partsFound); + isset_partsFound = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isStatsCompliant); + this->__isset.isStatsCompliant = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_colStats) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_partsFound) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AggrStats::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AggrStats"); + + xfer += oprot->writeFieldBegin("colStats", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->colStats.size())); + std::vector ::const_iterator _iter492; + for (_iter492 = this->colStats.begin(); _iter492 != this->colStats.end(); ++_iter492) + { + xfer += (*_iter492).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("partsFound", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->partsFound); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.isStatsCompliant) { + xfer += oprot->writeFieldBegin("isStatsCompliant", ::apache::thrift::protocol::T_BOOL, 3); + xfer += oprot->writeBool(this->isStatsCompliant); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AggrStats &a, AggrStats &b) noexcept { + using ::std::swap; + swap(a.colStats, b.colStats); + swap(a.partsFound, b.partsFound); + swap(a.isStatsCompliant, b.isStatsCompliant); + swap(a.__isset, b.__isset); +} + +bool AggrStats::operator==(const AggrStats & rhs) const +{ + if (!(colStats == rhs.colStats)) + return false; + if (!(partsFound == rhs.partsFound)) + return false; + if (__isset.isStatsCompliant != rhs.__isset.isStatsCompliant) + return false; + else if (__isset.isStatsCompliant && !(isStatsCompliant == rhs.isStatsCompliant)) + return false; + return true; +} + +AggrStats::AggrStats(const AggrStats& other493) { + colStats = other493.colStats; + partsFound = other493.partsFound; + isStatsCompliant = other493.isStatsCompliant; + __isset = other493.__isset; +} +AggrStats& AggrStats::operator=(const AggrStats& other494) { + colStats = other494.colStats; + partsFound = other494.partsFound; + isStatsCompliant = other494.isStatsCompliant; + __isset = other494.__isset; + return *this; +} +void AggrStats::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AggrStats("; + out << "colStats=" << to_string(colStats); + out << ", " << "partsFound=" << to_string(partsFound); + out << ", " << "isStatsCompliant="; (__isset.isStatsCompliant ? (out << to_string(isStatsCompliant)) : (out << "")); + out << ")"; +} + + +SetPartitionsStatsRequest::~SetPartitionsStatsRequest() noexcept { +} + +SetPartitionsStatsRequest::SetPartitionsStatsRequest() : needMerge(0), + writeId(-1LL), + validWriteIdList(), + engine("hive") { +} + +void SetPartitionsStatsRequest::__set_colStats(const std::vector & val) { + this->colStats = val; +} + +void SetPartitionsStatsRequest::__set_needMerge(const bool val) { + this->needMerge = val; +__isset.needMerge = true; +} + +void SetPartitionsStatsRequest::__set_writeId(const int64_t val) { + this->writeId = val; +__isset.writeId = true; +} + +void SetPartitionsStatsRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void SetPartitionsStatsRequest::__set_engine(const std::string& val) { + this->engine = val; +__isset.engine = true; +} +std::ostream& operator<<(std::ostream& out, const SetPartitionsStatsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t SetPartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_colStats = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->colStats.clear(); + uint32_t _size495; + ::apache::thrift::protocol::TType _etype498; + xfer += iprot->readListBegin(_etype498, _size495); + this->colStats.resize(_size495); + uint32_t _i499; + for (_i499 = 0; _i499 < _size495; ++_i499) + { + xfer += this->colStats[_i499].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_colStats = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->needMerge); + this->__isset.needMerge = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->writeId); + this->__isset.writeId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->engine); + this->__isset.engine = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_colStats) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t SetPartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("SetPartitionsStatsRequest"); + + xfer += oprot->writeFieldBegin("colStats", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->colStats.size())); + std::vector ::const_iterator _iter500; + for (_iter500 = this->colStats.begin(); _iter500 != this->colStats.end(); ++_iter500) + { + xfer += (*_iter500).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.needMerge) { + xfer += oprot->writeFieldBegin("needMerge", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool(this->needMerge); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.writeId) { + xfer += oprot->writeFieldBegin("writeId", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->writeId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.engine) { + xfer += oprot->writeFieldBegin("engine", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->engine); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(SetPartitionsStatsRequest &a, SetPartitionsStatsRequest &b) noexcept { + using ::std::swap; + swap(a.colStats, b.colStats); + swap(a.needMerge, b.needMerge); + swap(a.writeId, b.writeId); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.engine, b.engine); + swap(a.__isset, b.__isset); +} + +bool SetPartitionsStatsRequest::operator==(const SetPartitionsStatsRequest & rhs) const +{ + if (!(colStats == rhs.colStats)) + return false; + if (__isset.needMerge != rhs.__isset.needMerge) + return false; + else if (__isset.needMerge && !(needMerge == rhs.needMerge)) + return false; + if (__isset.writeId != rhs.__isset.writeId) + return false; + else if (__isset.writeId && !(writeId == rhs.writeId)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.engine != rhs.__isset.engine) + return false; + else if (__isset.engine && !(engine == rhs.engine)) + return false; + return true; +} + +SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other501) { + colStats = other501.colStats; + needMerge = other501.needMerge; + writeId = other501.writeId; + validWriteIdList = other501.validWriteIdList; + engine = other501.engine; + __isset = other501.__isset; +} +SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other502) { + colStats = other502.colStats; + needMerge = other502.needMerge; + writeId = other502.writeId; + validWriteIdList = other502.validWriteIdList; + engine = other502.engine; + __isset = other502.__isset; + return *this; +} +void SetPartitionsStatsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "SetPartitionsStatsRequest("; + out << "colStats=" << to_string(colStats); + out << ", " << "needMerge="; (__isset.needMerge ? (out << to_string(needMerge)) : (out << "")); + out << ", " << "writeId="; (__isset.writeId ? (out << to_string(writeId)) : (out << "")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "engine="; (__isset.engine ? (out << to_string(engine)) : (out << "")); + out << ")"; +} + + +SetPartitionsStatsResponse::~SetPartitionsStatsResponse() noexcept { +} + +SetPartitionsStatsResponse::SetPartitionsStatsResponse() noexcept + : result(0) { +} + +void SetPartitionsStatsResponse::__set_result(const bool val) { + this->result = val; +} +std::ostream& operator<<(std::ostream& out, const SetPartitionsStatsResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t SetPartitionsStatsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_result = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->result); + isset_result = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_result) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t SetPartitionsStatsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("SetPartitionsStatsResponse"); + + xfer += oprot->writeFieldBegin("result", ::apache::thrift::protocol::T_BOOL, 1); + xfer += oprot->writeBool(this->result); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(SetPartitionsStatsResponse &a, SetPartitionsStatsResponse &b) noexcept { + using ::std::swap; + swap(a.result, b.result); +} + +bool SetPartitionsStatsResponse::operator==(const SetPartitionsStatsResponse & rhs) const +{ + if (!(result == rhs.result)) + return false; + return true; +} + +SetPartitionsStatsResponse::SetPartitionsStatsResponse(const SetPartitionsStatsResponse& other503) noexcept { + result = other503.result; +} +SetPartitionsStatsResponse& SetPartitionsStatsResponse::operator=(const SetPartitionsStatsResponse& other504) noexcept { + result = other504.result; + return *this; +} +void SetPartitionsStatsResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "SetPartitionsStatsResponse("; + out << "result=" << to_string(result); + out << ")"; +} + + +Schema::~Schema() noexcept { +} + +Schema::Schema() noexcept { +} + +void Schema::__set_fieldSchemas(const std::vector & val) { + this->fieldSchemas = val; +} + +void Schema::__set_properties(const std::map & val) { + this->properties = val; +} +std::ostream& operator<<(std::ostream& out, const Schema& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->fieldSchemas.clear(); + uint32_t _size505; + ::apache::thrift::protocol::TType _etype508; + xfer += iprot->readListBegin(_etype508, _size505); + this->fieldSchemas.resize(_size505); + uint32_t _i509; + for (_i509 = 0; _i509 < _size505; ++_i509) + { + xfer += this->fieldSchemas[_i509].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.fieldSchemas = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->properties.clear(); + uint32_t _size510; + ::apache::thrift::protocol::TType _ktype511; + ::apache::thrift::protocol::TType _vtype512; + xfer += iprot->readMapBegin(_ktype511, _vtype512, _size510); + uint32_t _i514; + for (_i514 = 0; _i514 < _size510; ++_i514) + { + std::string _key515; + xfer += iprot->readString(_key515); + std::string& _val516 = this->properties[_key515]; + xfer += iprot->readString(_val516); + } + xfer += iprot->readMapEnd(); + } + this->__isset.properties = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Schema::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Schema"); + + xfer += oprot->writeFieldBegin("fieldSchemas", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->fieldSchemas.size())); + std::vector ::const_iterator _iter517; + for (_iter517 = this->fieldSchemas.begin(); _iter517 != this->fieldSchemas.end(); ++_iter517) + { + xfer += (*_iter517).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 2); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->properties.size())); + std::map ::const_iterator _iter518; + for (_iter518 = this->properties.begin(); _iter518 != this->properties.end(); ++_iter518) + { + xfer += oprot->writeString(_iter518->first); + xfer += oprot->writeString(_iter518->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Schema &a, Schema &b) noexcept { + using ::std::swap; + swap(a.fieldSchemas, b.fieldSchemas); + swap(a.properties, b.properties); + swap(a.__isset, b.__isset); +} + +bool Schema::operator==(const Schema & rhs) const +{ + if (!(fieldSchemas == rhs.fieldSchemas)) + return false; + if (!(properties == rhs.properties)) + return false; + return true; +} + +Schema::Schema(const Schema& other519) { + fieldSchemas = other519.fieldSchemas; + properties = other519.properties; + __isset = other519.__isset; +} +Schema& Schema::operator=(const Schema& other520) { + fieldSchemas = other520.fieldSchemas; + properties = other520.properties; + __isset = other520.__isset; + return *this; +} +void Schema::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Schema("; + out << "fieldSchemas=" << to_string(fieldSchemas); + out << ", " << "properties=" << to_string(properties); + out << ")"; +} + + +PrimaryKeysRequest::~PrimaryKeysRequest() noexcept { +} + +PrimaryKeysRequest::PrimaryKeysRequest() noexcept + : db_name(), + tbl_name(), + catName(), + validWriteIdList(), + tableId(-1LL) { +} + +void PrimaryKeysRequest::__set_db_name(const std::string& val) { + this->db_name = val; +} + +void PrimaryKeysRequest::__set_tbl_name(const std::string& val) { + this->tbl_name = val; +} + +void PrimaryKeysRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void PrimaryKeysRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void PrimaryKeysRequest::__set_tableId(const int64_t val) { + this->tableId = val; +__isset.tableId = true; +} +std::ostream& operator<<(std::ostream& out, const PrimaryKeysRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PrimaryKeysRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_db_name = false; + bool isset_tbl_name = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + isset_db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + isset_tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->tableId); + this->__isset.tableId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_db_name) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tbl_name) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t PrimaryKeysRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PrimaryKeysRequest"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.tableId) { + xfer += oprot->writeFieldBegin("tableId", ::apache::thrift::protocol::T_I64, 5); + xfer += oprot->writeI64(this->tableId); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PrimaryKeysRequest &a, PrimaryKeysRequest &b) noexcept { + using ::std::swap; + swap(a.db_name, b.db_name); + swap(a.tbl_name, b.tbl_name); + swap(a.catName, b.catName); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.tableId, b.tableId); + swap(a.__isset, b.__isset); +} + +bool PrimaryKeysRequest::operator==(const PrimaryKeysRequest & rhs) const +{ + if (!(db_name == rhs.db_name)) + return false; + if (!(tbl_name == rhs.tbl_name)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.tableId != rhs.__isset.tableId) + return false; + else if (__isset.tableId && !(tableId == rhs.tableId)) + return false; + return true; +} + +PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other521) { + db_name = other521.db_name; + tbl_name = other521.tbl_name; + catName = other521.catName; + validWriteIdList = other521.validWriteIdList; + tableId = other521.tableId; + __isset = other521.__isset; +} +PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other522) { + db_name = other522.db_name; + tbl_name = other522.tbl_name; + catName = other522.catName; + validWriteIdList = other522.validWriteIdList; + tableId = other522.tableId; + __isset = other522.__isset; + return *this; +} +void PrimaryKeysRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PrimaryKeysRequest("; + out << "db_name=" << to_string(db_name); + out << ", " << "tbl_name=" << to_string(tbl_name); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "tableId="; (__isset.tableId ? (out << to_string(tableId)) : (out << "")); + out << ")"; +} + + +PrimaryKeysResponse::~PrimaryKeysResponse() noexcept { +} + +PrimaryKeysResponse::PrimaryKeysResponse() noexcept { +} + +void PrimaryKeysResponse::__set_primaryKeys(const std::vector & val) { + this->primaryKeys = val; +} +std::ostream& operator<<(std::ostream& out, const PrimaryKeysResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PrimaryKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_primaryKeys = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->primaryKeys.clear(); + uint32_t _size523; + ::apache::thrift::protocol::TType _etype526; + xfer += iprot->readListBegin(_etype526, _size523); + this->primaryKeys.resize(_size523); + uint32_t _i527; + for (_i527 = 0; _i527 < _size523; ++_i527) + { + xfer += this->primaryKeys[_i527].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_primaryKeys = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_primaryKeys) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t PrimaryKeysResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PrimaryKeysResponse"); + + xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->primaryKeys.size())); + std::vector ::const_iterator _iter528; + for (_iter528 = this->primaryKeys.begin(); _iter528 != this->primaryKeys.end(); ++_iter528) + { + xfer += (*_iter528).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PrimaryKeysResponse &a, PrimaryKeysResponse &b) noexcept { + using ::std::swap; + swap(a.primaryKeys, b.primaryKeys); +} + +bool PrimaryKeysResponse::operator==(const PrimaryKeysResponse & rhs) const +{ + if (!(primaryKeys == rhs.primaryKeys)) + return false; + return true; +} + +PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other529) { + primaryKeys = other529.primaryKeys; +} +PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other530) { + primaryKeys = other530.primaryKeys; + return *this; +} +void PrimaryKeysResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PrimaryKeysResponse("; + out << "primaryKeys=" << to_string(primaryKeys); + out << ")"; +} + + +ForeignKeysRequest::~ForeignKeysRequest() noexcept { +} + +ForeignKeysRequest::ForeignKeysRequest() noexcept + : parent_db_name(), + parent_tbl_name(), + foreign_db_name(), + foreign_tbl_name(), + catName(), + validWriteIdList(), + tableId(-1LL) { +} + +void ForeignKeysRequest::__set_parent_db_name(const std::string& val) { + this->parent_db_name = val; +} + +void ForeignKeysRequest::__set_parent_tbl_name(const std::string& val) { + this->parent_tbl_name = val; +} + +void ForeignKeysRequest::__set_foreign_db_name(const std::string& val) { + this->foreign_db_name = val; +} + +void ForeignKeysRequest::__set_foreign_tbl_name(const std::string& val) { + this->foreign_tbl_name = val; +} + +void ForeignKeysRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void ForeignKeysRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void ForeignKeysRequest::__set_tableId(const int64_t val) { + this->tableId = val; +__isset.tableId = true; +} +std::ostream& operator<<(std::ostream& out, const ForeignKeysRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ForeignKeysRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->parent_db_name); + this->__isset.parent_db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->parent_tbl_name); + this->__isset.parent_tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->foreign_db_name); + this->__isset.foreign_db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->foreign_tbl_name); + this->__isset.foreign_tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->tableId); + this->__isset.tableId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ForeignKeysRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ForeignKeysRequest"); + + xfer += oprot->writeFieldBegin("parent_db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->parent_db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("parent_tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->parent_tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("foreign_db_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->foreign_db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("foreign_tbl_name", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->foreign_tbl_name); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.tableId) { + xfer += oprot->writeFieldBegin("tableId", ::apache::thrift::protocol::T_I64, 7); + xfer += oprot->writeI64(this->tableId); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ForeignKeysRequest &a, ForeignKeysRequest &b) noexcept { + using ::std::swap; + swap(a.parent_db_name, b.parent_db_name); + swap(a.parent_tbl_name, b.parent_tbl_name); + swap(a.foreign_db_name, b.foreign_db_name); + swap(a.foreign_tbl_name, b.foreign_tbl_name); + swap(a.catName, b.catName); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.tableId, b.tableId); + swap(a.__isset, b.__isset); +} + +bool ForeignKeysRequest::operator==(const ForeignKeysRequest & rhs) const +{ + if (!(parent_db_name == rhs.parent_db_name)) + return false; + if (!(parent_tbl_name == rhs.parent_tbl_name)) + return false; + if (!(foreign_db_name == rhs.foreign_db_name)) + return false; + if (!(foreign_tbl_name == rhs.foreign_tbl_name)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.tableId != rhs.__isset.tableId) + return false; + else if (__isset.tableId && !(tableId == rhs.tableId)) + return false; + return true; +} + +ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other531) { + parent_db_name = other531.parent_db_name; + parent_tbl_name = other531.parent_tbl_name; + foreign_db_name = other531.foreign_db_name; + foreign_tbl_name = other531.foreign_tbl_name; + catName = other531.catName; + validWriteIdList = other531.validWriteIdList; + tableId = other531.tableId; + __isset = other531.__isset; +} +ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other532) { + parent_db_name = other532.parent_db_name; + parent_tbl_name = other532.parent_tbl_name; + foreign_db_name = other532.foreign_db_name; + foreign_tbl_name = other532.foreign_tbl_name; + catName = other532.catName; + validWriteIdList = other532.validWriteIdList; + tableId = other532.tableId; + __isset = other532.__isset; + return *this; +} +void ForeignKeysRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ForeignKeysRequest("; + out << "parent_db_name=" << to_string(parent_db_name); + out << ", " << "parent_tbl_name=" << to_string(parent_tbl_name); + out << ", " << "foreign_db_name=" << to_string(foreign_db_name); + out << ", " << "foreign_tbl_name=" << to_string(foreign_tbl_name); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "tableId="; (__isset.tableId ? (out << to_string(tableId)) : (out << "")); + out << ")"; +} + + +ForeignKeysResponse::~ForeignKeysResponse() noexcept { +} + +ForeignKeysResponse::ForeignKeysResponse() noexcept { +} + +void ForeignKeysResponse::__set_foreignKeys(const std::vector & val) { + this->foreignKeys = val; +} +std::ostream& operator<<(std::ostream& out, const ForeignKeysResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ForeignKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_foreignKeys = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->foreignKeys.clear(); + uint32_t _size533; + ::apache::thrift::protocol::TType _etype536; + xfer += iprot->readListBegin(_etype536, _size533); + this->foreignKeys.resize(_size533); + uint32_t _i537; + for (_i537 = 0; _i537 < _size533; ++_i537) + { + xfer += this->foreignKeys[_i537].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_foreignKeys = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_foreignKeys) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ForeignKeysResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ForeignKeysResponse"); + + xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->foreignKeys.size())); + std::vector ::const_iterator _iter538; + for (_iter538 = this->foreignKeys.begin(); _iter538 != this->foreignKeys.end(); ++_iter538) + { + xfer += (*_iter538).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ForeignKeysResponse &a, ForeignKeysResponse &b) noexcept { + using ::std::swap; + swap(a.foreignKeys, b.foreignKeys); +} + +bool ForeignKeysResponse::operator==(const ForeignKeysResponse & rhs) const +{ + if (!(foreignKeys == rhs.foreignKeys)) + return false; + return true; +} + +ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other539) { + foreignKeys = other539.foreignKeys; +} +ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other540) { + foreignKeys = other540.foreignKeys; + return *this; +} +void ForeignKeysResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ForeignKeysResponse("; + out << "foreignKeys=" << to_string(foreignKeys); + out << ")"; +} + + +UniqueConstraintsRequest::~UniqueConstraintsRequest() noexcept { +} + +UniqueConstraintsRequest::UniqueConstraintsRequest() noexcept + : catName(), + db_name(), + tbl_name(), + validWriteIdList(), + tableId(-1LL) { +} + +void UniqueConstraintsRequest::__set_catName(const std::string& val) { + this->catName = val; +} + +void UniqueConstraintsRequest::__set_db_name(const std::string& val) { + this->db_name = val; +} + +void UniqueConstraintsRequest::__set_tbl_name(const std::string& val) { + this->tbl_name = val; +} + +void UniqueConstraintsRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void UniqueConstraintsRequest::__set_tableId(const int64_t val) { + this->tableId = val; +__isset.tableId = true; +} +std::ostream& operator<<(std::ostream& out, const UniqueConstraintsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t UniqueConstraintsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_catName = false; + bool isset_db_name = false; + bool isset_tbl_name = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + isset_catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + isset_db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + isset_tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->tableId); + this->__isset.tableId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_catName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_db_name) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tbl_name) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t UniqueConstraintsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("UniqueConstraintsRequest"); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.tableId) { + xfer += oprot->writeFieldBegin("tableId", ::apache::thrift::protocol::T_I64, 5); + xfer += oprot->writeI64(this->tableId); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(UniqueConstraintsRequest &a, UniqueConstraintsRequest &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.db_name, b.db_name); + swap(a.tbl_name, b.tbl_name); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.tableId, b.tableId); + swap(a.__isset, b.__isset); +} + +bool UniqueConstraintsRequest::operator==(const UniqueConstraintsRequest & rhs) const +{ + if (!(catName == rhs.catName)) + return false; + if (!(db_name == rhs.db_name)) + return false; + if (!(tbl_name == rhs.tbl_name)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.tableId != rhs.__isset.tableId) + return false; + else if (__isset.tableId && !(tableId == rhs.tableId)) + return false; + return true; +} + +UniqueConstraintsRequest::UniqueConstraintsRequest(const UniqueConstraintsRequest& other541) { + catName = other541.catName; + db_name = other541.db_name; + tbl_name = other541.tbl_name; + validWriteIdList = other541.validWriteIdList; + tableId = other541.tableId; + __isset = other541.__isset; +} +UniqueConstraintsRequest& UniqueConstraintsRequest::operator=(const UniqueConstraintsRequest& other542) { + catName = other542.catName; + db_name = other542.db_name; + tbl_name = other542.tbl_name; + validWriteIdList = other542.validWriteIdList; + tableId = other542.tableId; + __isset = other542.__isset; + return *this; +} +void UniqueConstraintsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "UniqueConstraintsRequest("; + out << "catName=" << to_string(catName); + out << ", " << "db_name=" << to_string(db_name); + out << ", " << "tbl_name=" << to_string(tbl_name); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "tableId="; (__isset.tableId ? (out << to_string(tableId)) : (out << "")); + out << ")"; +} + + +UniqueConstraintsResponse::~UniqueConstraintsResponse() noexcept { +} + +UniqueConstraintsResponse::UniqueConstraintsResponse() noexcept { +} + +void UniqueConstraintsResponse::__set_uniqueConstraints(const std::vector & val) { + this->uniqueConstraints = val; +} +std::ostream& operator<<(std::ostream& out, const UniqueConstraintsResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t UniqueConstraintsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_uniqueConstraints = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->uniqueConstraints.clear(); + uint32_t _size543; + ::apache::thrift::protocol::TType _etype546; + xfer += iprot->readListBegin(_etype546, _size543); + this->uniqueConstraints.resize(_size543); + uint32_t _i547; + for (_i547 = 0; _i547 < _size543; ++_i547) + { + xfer += this->uniqueConstraints[_i547].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_uniqueConstraints = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_uniqueConstraints) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t UniqueConstraintsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("UniqueConstraintsResponse"); + + xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->uniqueConstraints.size())); + std::vector ::const_iterator _iter548; + for (_iter548 = this->uniqueConstraints.begin(); _iter548 != this->uniqueConstraints.end(); ++_iter548) + { + xfer += (*_iter548).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(UniqueConstraintsResponse &a, UniqueConstraintsResponse &b) noexcept { + using ::std::swap; + swap(a.uniqueConstraints, b.uniqueConstraints); +} + +bool UniqueConstraintsResponse::operator==(const UniqueConstraintsResponse & rhs) const +{ + if (!(uniqueConstraints == rhs.uniqueConstraints)) + return false; + return true; +} + +UniqueConstraintsResponse::UniqueConstraintsResponse(const UniqueConstraintsResponse& other549) { + uniqueConstraints = other549.uniqueConstraints; +} +UniqueConstraintsResponse& UniqueConstraintsResponse::operator=(const UniqueConstraintsResponse& other550) { + uniqueConstraints = other550.uniqueConstraints; + return *this; +} +void UniqueConstraintsResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "UniqueConstraintsResponse("; + out << "uniqueConstraints=" << to_string(uniqueConstraints); + out << ")"; +} + + +NotNullConstraintsRequest::~NotNullConstraintsRequest() noexcept { +} + +NotNullConstraintsRequest::NotNullConstraintsRequest() noexcept + : catName(), + db_name(), + tbl_name(), + validWriteIdList(), + tableId(-1LL) { +} + +void NotNullConstraintsRequest::__set_catName(const std::string& val) { + this->catName = val; +} + +void NotNullConstraintsRequest::__set_db_name(const std::string& val) { + this->db_name = val; +} + +void NotNullConstraintsRequest::__set_tbl_name(const std::string& val) { + this->tbl_name = val; +} + +void NotNullConstraintsRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void NotNullConstraintsRequest::__set_tableId(const int64_t val) { + this->tableId = val; +__isset.tableId = true; +} +std::ostream& operator<<(std::ostream& out, const NotNullConstraintsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t NotNullConstraintsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_catName = false; + bool isset_db_name = false; + bool isset_tbl_name = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + isset_catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + isset_db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + isset_tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->tableId); + this->__isset.tableId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_catName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_db_name) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tbl_name) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t NotNullConstraintsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("NotNullConstraintsRequest"); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.tableId) { + xfer += oprot->writeFieldBegin("tableId", ::apache::thrift::protocol::T_I64, 5); + xfer += oprot->writeI64(this->tableId); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(NotNullConstraintsRequest &a, NotNullConstraintsRequest &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.db_name, b.db_name); + swap(a.tbl_name, b.tbl_name); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.tableId, b.tableId); + swap(a.__isset, b.__isset); +} + +bool NotNullConstraintsRequest::operator==(const NotNullConstraintsRequest & rhs) const +{ + if (!(catName == rhs.catName)) + return false; + if (!(db_name == rhs.db_name)) + return false; + if (!(tbl_name == rhs.tbl_name)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.tableId != rhs.__isset.tableId) + return false; + else if (__isset.tableId && !(tableId == rhs.tableId)) + return false; + return true; +} + +NotNullConstraintsRequest::NotNullConstraintsRequest(const NotNullConstraintsRequest& other551) { + catName = other551.catName; + db_name = other551.db_name; + tbl_name = other551.tbl_name; + validWriteIdList = other551.validWriteIdList; + tableId = other551.tableId; + __isset = other551.__isset; +} +NotNullConstraintsRequest& NotNullConstraintsRequest::operator=(const NotNullConstraintsRequest& other552) { + catName = other552.catName; + db_name = other552.db_name; + tbl_name = other552.tbl_name; + validWriteIdList = other552.validWriteIdList; + tableId = other552.tableId; + __isset = other552.__isset; + return *this; +} +void NotNullConstraintsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "NotNullConstraintsRequest("; + out << "catName=" << to_string(catName); + out << ", " << "db_name=" << to_string(db_name); + out << ", " << "tbl_name=" << to_string(tbl_name); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "tableId="; (__isset.tableId ? (out << to_string(tableId)) : (out << "")); + out << ")"; +} + + +NotNullConstraintsResponse::~NotNullConstraintsResponse() noexcept { +} + +NotNullConstraintsResponse::NotNullConstraintsResponse() noexcept { +} + +void NotNullConstraintsResponse::__set_notNullConstraints(const std::vector & val) { + this->notNullConstraints = val; +} +std::ostream& operator<<(std::ostream& out, const NotNullConstraintsResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t NotNullConstraintsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_notNullConstraints = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->notNullConstraints.clear(); + uint32_t _size553; + ::apache::thrift::protocol::TType _etype556; + xfer += iprot->readListBegin(_etype556, _size553); + this->notNullConstraints.resize(_size553); + uint32_t _i557; + for (_i557 = 0; _i557 < _size553; ++_i557) + { + xfer += this->notNullConstraints[_i557].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_notNullConstraints = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_notNullConstraints) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t NotNullConstraintsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("NotNullConstraintsResponse"); + + xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->notNullConstraints.size())); + std::vector ::const_iterator _iter558; + for (_iter558 = this->notNullConstraints.begin(); _iter558 != this->notNullConstraints.end(); ++_iter558) + { + xfer += (*_iter558).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(NotNullConstraintsResponse &a, NotNullConstraintsResponse &b) noexcept { + using ::std::swap; + swap(a.notNullConstraints, b.notNullConstraints); +} + +bool NotNullConstraintsResponse::operator==(const NotNullConstraintsResponse & rhs) const +{ + if (!(notNullConstraints == rhs.notNullConstraints)) + return false; + return true; +} + +NotNullConstraintsResponse::NotNullConstraintsResponse(const NotNullConstraintsResponse& other559) { + notNullConstraints = other559.notNullConstraints; +} +NotNullConstraintsResponse& NotNullConstraintsResponse::operator=(const NotNullConstraintsResponse& other560) { + notNullConstraints = other560.notNullConstraints; + return *this; +} +void NotNullConstraintsResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "NotNullConstraintsResponse("; + out << "notNullConstraints=" << to_string(notNullConstraints); + out << ")"; +} + + +DefaultConstraintsRequest::~DefaultConstraintsRequest() noexcept { +} + +DefaultConstraintsRequest::DefaultConstraintsRequest() noexcept + : catName(), + db_name(), + tbl_name(), + validWriteIdList(), + tableId(-1LL) { +} + +void DefaultConstraintsRequest::__set_catName(const std::string& val) { + this->catName = val; +} + +void DefaultConstraintsRequest::__set_db_name(const std::string& val) { + this->db_name = val; +} + +void DefaultConstraintsRequest::__set_tbl_name(const std::string& val) { + this->tbl_name = val; +} + +void DefaultConstraintsRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void DefaultConstraintsRequest::__set_tableId(const int64_t val) { + this->tableId = val; +__isset.tableId = true; +} +std::ostream& operator<<(std::ostream& out, const DefaultConstraintsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t DefaultConstraintsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_catName = false; + bool isset_db_name = false; + bool isset_tbl_name = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + isset_catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + isset_db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + isset_tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->tableId); + this->__isset.tableId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_catName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_db_name) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tbl_name) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t DefaultConstraintsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("DefaultConstraintsRequest"); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.tableId) { + xfer += oprot->writeFieldBegin("tableId", ::apache::thrift::protocol::T_I64, 5); + xfer += oprot->writeI64(this->tableId); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(DefaultConstraintsRequest &a, DefaultConstraintsRequest &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.db_name, b.db_name); + swap(a.tbl_name, b.tbl_name); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.tableId, b.tableId); + swap(a.__isset, b.__isset); +} + +bool DefaultConstraintsRequest::operator==(const DefaultConstraintsRequest & rhs) const +{ + if (!(catName == rhs.catName)) + return false; + if (!(db_name == rhs.db_name)) + return false; + if (!(tbl_name == rhs.tbl_name)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.tableId != rhs.__isset.tableId) + return false; + else if (__isset.tableId && !(tableId == rhs.tableId)) + return false; + return true; +} + +DefaultConstraintsRequest::DefaultConstraintsRequest(const DefaultConstraintsRequest& other561) { + catName = other561.catName; + db_name = other561.db_name; + tbl_name = other561.tbl_name; + validWriteIdList = other561.validWriteIdList; + tableId = other561.tableId; + __isset = other561.__isset; +} +DefaultConstraintsRequest& DefaultConstraintsRequest::operator=(const DefaultConstraintsRequest& other562) { + catName = other562.catName; + db_name = other562.db_name; + tbl_name = other562.tbl_name; + validWriteIdList = other562.validWriteIdList; + tableId = other562.tableId; + __isset = other562.__isset; + return *this; +} +void DefaultConstraintsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "DefaultConstraintsRequest("; + out << "catName=" << to_string(catName); + out << ", " << "db_name=" << to_string(db_name); + out << ", " << "tbl_name=" << to_string(tbl_name); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "tableId="; (__isset.tableId ? (out << to_string(tableId)) : (out << "")); + out << ")"; +} + + +DefaultConstraintsResponse::~DefaultConstraintsResponse() noexcept { +} + +DefaultConstraintsResponse::DefaultConstraintsResponse() noexcept { +} + +void DefaultConstraintsResponse::__set_defaultConstraints(const std::vector & val) { + this->defaultConstraints = val; +} +std::ostream& operator<<(std::ostream& out, const DefaultConstraintsResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t DefaultConstraintsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_defaultConstraints = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->defaultConstraints.clear(); + uint32_t _size563; + ::apache::thrift::protocol::TType _etype566; + xfer += iprot->readListBegin(_etype566, _size563); + this->defaultConstraints.resize(_size563); + uint32_t _i567; + for (_i567 = 0; _i567 < _size563; ++_i567) + { + xfer += this->defaultConstraints[_i567].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_defaultConstraints = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_defaultConstraints) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t DefaultConstraintsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("DefaultConstraintsResponse"); + + xfer += oprot->writeFieldBegin("defaultConstraints", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->defaultConstraints.size())); + std::vector ::const_iterator _iter568; + for (_iter568 = this->defaultConstraints.begin(); _iter568 != this->defaultConstraints.end(); ++_iter568) + { + xfer += (*_iter568).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(DefaultConstraintsResponse &a, DefaultConstraintsResponse &b) noexcept { + using ::std::swap; + swap(a.defaultConstraints, b.defaultConstraints); +} + +bool DefaultConstraintsResponse::operator==(const DefaultConstraintsResponse & rhs) const +{ + if (!(defaultConstraints == rhs.defaultConstraints)) + return false; + return true; +} + +DefaultConstraintsResponse::DefaultConstraintsResponse(const DefaultConstraintsResponse& other569) { + defaultConstraints = other569.defaultConstraints; +} +DefaultConstraintsResponse& DefaultConstraintsResponse::operator=(const DefaultConstraintsResponse& other570) { + defaultConstraints = other570.defaultConstraints; + return *this; +} +void DefaultConstraintsResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "DefaultConstraintsResponse("; + out << "defaultConstraints=" << to_string(defaultConstraints); + out << ")"; +} + + +CheckConstraintsRequest::~CheckConstraintsRequest() noexcept { +} + +CheckConstraintsRequest::CheckConstraintsRequest() noexcept + : catName(), + db_name(), + tbl_name(), + validWriteIdList(), + tableId(-1LL) { +} + +void CheckConstraintsRequest::__set_catName(const std::string& val) { + this->catName = val; +} + +void CheckConstraintsRequest::__set_db_name(const std::string& val) { + this->db_name = val; +} + +void CheckConstraintsRequest::__set_tbl_name(const std::string& val) { + this->tbl_name = val; +} + +void CheckConstraintsRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void CheckConstraintsRequest::__set_tableId(const int64_t val) { + this->tableId = val; +__isset.tableId = true; +} +std::ostream& operator<<(std::ostream& out, const CheckConstraintsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t CheckConstraintsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_catName = false; + bool isset_db_name = false; + bool isset_tbl_name = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + isset_catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + isset_db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + isset_tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->tableId); + this->__isset.tableId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_catName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_db_name) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tbl_name) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t CheckConstraintsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CheckConstraintsRequest"); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.tableId) { + xfer += oprot->writeFieldBegin("tableId", ::apache::thrift::protocol::T_I64, 5); + xfer += oprot->writeI64(this->tableId); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CheckConstraintsRequest &a, CheckConstraintsRequest &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.db_name, b.db_name); + swap(a.tbl_name, b.tbl_name); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.tableId, b.tableId); + swap(a.__isset, b.__isset); +} + +bool CheckConstraintsRequest::operator==(const CheckConstraintsRequest & rhs) const +{ + if (!(catName == rhs.catName)) + return false; + if (!(db_name == rhs.db_name)) + return false; + if (!(tbl_name == rhs.tbl_name)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.tableId != rhs.__isset.tableId) + return false; + else if (__isset.tableId && !(tableId == rhs.tableId)) + return false; + return true; +} + +CheckConstraintsRequest::CheckConstraintsRequest(const CheckConstraintsRequest& other571) { + catName = other571.catName; + db_name = other571.db_name; + tbl_name = other571.tbl_name; + validWriteIdList = other571.validWriteIdList; + tableId = other571.tableId; + __isset = other571.__isset; +} +CheckConstraintsRequest& CheckConstraintsRequest::operator=(const CheckConstraintsRequest& other572) { + catName = other572.catName; + db_name = other572.db_name; + tbl_name = other572.tbl_name; + validWriteIdList = other572.validWriteIdList; + tableId = other572.tableId; + __isset = other572.__isset; + return *this; +} +void CheckConstraintsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CheckConstraintsRequest("; + out << "catName=" << to_string(catName); + out << ", " << "db_name=" << to_string(db_name); + out << ", " << "tbl_name=" << to_string(tbl_name); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "tableId="; (__isset.tableId ? (out << to_string(tableId)) : (out << "")); + out << ")"; +} + + +CheckConstraintsResponse::~CheckConstraintsResponse() noexcept { +} + +CheckConstraintsResponse::CheckConstraintsResponse() noexcept { +} + +void CheckConstraintsResponse::__set_checkConstraints(const std::vector & val) { + this->checkConstraints = val; +} +std::ostream& operator<<(std::ostream& out, const CheckConstraintsResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t CheckConstraintsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_checkConstraints = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->checkConstraints.clear(); + uint32_t _size573; + ::apache::thrift::protocol::TType _etype576; + xfer += iprot->readListBegin(_etype576, _size573); + this->checkConstraints.resize(_size573); + uint32_t _i577; + for (_i577 = 0; _i577 < _size573; ++_i577) + { + xfer += this->checkConstraints[_i577].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_checkConstraints = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_checkConstraints) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t CheckConstraintsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CheckConstraintsResponse"); + + xfer += oprot->writeFieldBegin("checkConstraints", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->checkConstraints.size())); + std::vector ::const_iterator _iter578; + for (_iter578 = this->checkConstraints.begin(); _iter578 != this->checkConstraints.end(); ++_iter578) + { + xfer += (*_iter578).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CheckConstraintsResponse &a, CheckConstraintsResponse &b) noexcept { + using ::std::swap; + swap(a.checkConstraints, b.checkConstraints); +} + +bool CheckConstraintsResponse::operator==(const CheckConstraintsResponse & rhs) const +{ + if (!(checkConstraints == rhs.checkConstraints)) + return false; + return true; +} + +CheckConstraintsResponse::CheckConstraintsResponse(const CheckConstraintsResponse& other579) { + checkConstraints = other579.checkConstraints; +} +CheckConstraintsResponse& CheckConstraintsResponse::operator=(const CheckConstraintsResponse& other580) { + checkConstraints = other580.checkConstraints; + return *this; +} +void CheckConstraintsResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CheckConstraintsResponse("; + out << "checkConstraints=" << to_string(checkConstraints); + out << ")"; +} + + +AllTableConstraintsRequest::~AllTableConstraintsRequest() noexcept { +} + +AllTableConstraintsRequest::AllTableConstraintsRequest() noexcept + : dbName(), + tblName(), + catName(), + validWriteIdList(), + tableId(-1LL) { +} + +void AllTableConstraintsRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void AllTableConstraintsRequest::__set_tblName(const std::string& val) { + this->tblName = val; +} + +void AllTableConstraintsRequest::__set_catName(const std::string& val) { + this->catName = val; +} + +void AllTableConstraintsRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void AllTableConstraintsRequest::__set_tableId(const int64_t val) { + this->tableId = val; +__isset.tableId = true; +} +std::ostream& operator<<(std::ostream& out, const AllTableConstraintsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AllTableConstraintsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tblName = false; + bool isset_catName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tblName); + isset_tblName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + isset_catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->tableId); + this->__isset.tableId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tblName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_catName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AllTableConstraintsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AllTableConstraintsRequest"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tblName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.tableId) { + xfer += oprot->writeFieldBegin("tableId", ::apache::thrift::protocol::T_I64, 5); + xfer += oprot->writeI64(this->tableId); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AllTableConstraintsRequest &a, AllTableConstraintsRequest &b) noexcept { + using ::std::swap; + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); + swap(a.catName, b.catName); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.tableId, b.tableId); + swap(a.__isset, b.__isset); +} + +bool AllTableConstraintsRequest::operator==(const AllTableConstraintsRequest & rhs) const +{ + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + if (!(catName == rhs.catName)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.tableId != rhs.__isset.tableId) + return false; + else if (__isset.tableId && !(tableId == rhs.tableId)) + return false; + return true; +} + +AllTableConstraintsRequest::AllTableConstraintsRequest(const AllTableConstraintsRequest& other581) { + dbName = other581.dbName; + tblName = other581.tblName; + catName = other581.catName; + validWriteIdList = other581.validWriteIdList; + tableId = other581.tableId; + __isset = other581.__isset; +} +AllTableConstraintsRequest& AllTableConstraintsRequest::operator=(const AllTableConstraintsRequest& other582) { + dbName = other582.dbName; + tblName = other582.tblName; + catName = other582.catName; + validWriteIdList = other582.validWriteIdList; + tableId = other582.tableId; + __isset = other582.__isset; + return *this; +} +void AllTableConstraintsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AllTableConstraintsRequest("; + out << "dbName=" << to_string(dbName); + out << ", " << "tblName=" << to_string(tblName); + out << ", " << "catName=" << to_string(catName); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "tableId="; (__isset.tableId ? (out << to_string(tableId)) : (out << "")); + out << ")"; +} + + +AllTableConstraintsResponse::~AllTableConstraintsResponse() noexcept { +} + +AllTableConstraintsResponse::AllTableConstraintsResponse() noexcept { +} + +void AllTableConstraintsResponse::__set_allTableConstraints(const SQLAllTableConstraints& val) { + this->allTableConstraints = val; +} +std::ostream& operator<<(std::ostream& out, const AllTableConstraintsResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AllTableConstraintsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_allTableConstraints = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->allTableConstraints.read(iprot); + isset_allTableConstraints = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_allTableConstraints) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AllTableConstraintsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AllTableConstraintsResponse"); + + xfer += oprot->writeFieldBegin("allTableConstraints", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->allTableConstraints.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AllTableConstraintsResponse &a, AllTableConstraintsResponse &b) noexcept { + using ::std::swap; + swap(a.allTableConstraints, b.allTableConstraints); +} + +bool AllTableConstraintsResponse::operator==(const AllTableConstraintsResponse & rhs) const +{ + if (!(allTableConstraints == rhs.allTableConstraints)) + return false; + return true; +} + +AllTableConstraintsResponse::AllTableConstraintsResponse(const AllTableConstraintsResponse& other583) { + allTableConstraints = other583.allTableConstraints; +} +AllTableConstraintsResponse& AllTableConstraintsResponse::operator=(const AllTableConstraintsResponse& other584) { + allTableConstraints = other584.allTableConstraints; + return *this; +} +void AllTableConstraintsResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AllTableConstraintsResponse("; + out << "allTableConstraints=" << to_string(allTableConstraints); + out << ")"; +} + + +DropConstraintRequest::~DropConstraintRequest() noexcept { +} + +DropConstraintRequest::DropConstraintRequest() noexcept + : dbname(), + tablename(), + constraintname(), + catName() { +} + +void DropConstraintRequest::__set_dbname(const std::string& val) { + this->dbname = val; +} + +void DropConstraintRequest::__set_tablename(const std::string& val) { + this->tablename = val; +} + +void DropConstraintRequest::__set_constraintname(const std::string& val) { + this->constraintname = val; +} + +void DropConstraintRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} +std::ostream& operator<<(std::ostream& out, const DropConstraintRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t DropConstraintRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbname = false; + bool isset_tablename = false; + bool isset_constraintname = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbname); + isset_dbname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tablename); + isset_tablename = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->constraintname); + isset_constraintname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbname) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tablename) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_constraintname) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t DropConstraintRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("DropConstraintRequest"); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbname); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tablename", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tablename); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("constraintname", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->constraintname); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(DropConstraintRequest &a, DropConstraintRequest &b) noexcept { + using ::std::swap; + swap(a.dbname, b.dbname); + swap(a.tablename, b.tablename); + swap(a.constraintname, b.constraintname); + swap(a.catName, b.catName); + swap(a.__isset, b.__isset); +} + +bool DropConstraintRequest::operator==(const DropConstraintRequest & rhs) const +{ + if (!(dbname == rhs.dbname)) + return false; + if (!(tablename == rhs.tablename)) + return false; + if (!(constraintname == rhs.constraintname)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + return true; +} + +DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other585) { + dbname = other585.dbname; + tablename = other585.tablename; + constraintname = other585.constraintname; + catName = other585.catName; + __isset = other585.__isset; +} +DropConstraintRequest& DropConstraintRequest::operator=(const DropConstraintRequest& other586) { + dbname = other586.dbname; + tablename = other586.tablename; + constraintname = other586.constraintname; + catName = other586.catName; + __isset = other586.__isset; + return *this; +} +void DropConstraintRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "DropConstraintRequest("; + out << "dbname=" << to_string(dbname); + out << ", " << "tablename=" << to_string(tablename); + out << ", " << "constraintname=" << to_string(constraintname); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ")"; +} + + +AddPrimaryKeyRequest::~AddPrimaryKeyRequest() noexcept { +} + +AddPrimaryKeyRequest::AddPrimaryKeyRequest() noexcept { +} + +void AddPrimaryKeyRequest::__set_primaryKeyCols(const std::vector & val) { + this->primaryKeyCols = val; +} +std::ostream& operator<<(std::ostream& out, const AddPrimaryKeyRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AddPrimaryKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_primaryKeyCols = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->primaryKeyCols.clear(); + uint32_t _size587; + ::apache::thrift::protocol::TType _etype590; + xfer += iprot->readListBegin(_etype590, _size587); + this->primaryKeyCols.resize(_size587); + uint32_t _i591; + for (_i591 = 0; _i591 < _size587; ++_i591) + { + xfer += this->primaryKeyCols[_i591].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_primaryKeyCols = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_primaryKeyCols) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AddPrimaryKeyRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AddPrimaryKeyRequest"); + + xfer += oprot->writeFieldBegin("primaryKeyCols", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->primaryKeyCols.size())); + std::vector ::const_iterator _iter592; + for (_iter592 = this->primaryKeyCols.begin(); _iter592 != this->primaryKeyCols.end(); ++_iter592) + { + xfer += (*_iter592).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AddPrimaryKeyRequest &a, AddPrimaryKeyRequest &b) noexcept { + using ::std::swap; + swap(a.primaryKeyCols, b.primaryKeyCols); +} + +bool AddPrimaryKeyRequest::operator==(const AddPrimaryKeyRequest & rhs) const +{ + if (!(primaryKeyCols == rhs.primaryKeyCols)) + return false; + return true; +} + +AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& other593) { + primaryKeyCols = other593.primaryKeyCols; +} +AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const AddPrimaryKeyRequest& other594) { + primaryKeyCols = other594.primaryKeyCols; + return *this; +} +void AddPrimaryKeyRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AddPrimaryKeyRequest("; + out << "primaryKeyCols=" << to_string(primaryKeyCols); + out << ")"; +} + + +AddForeignKeyRequest::~AddForeignKeyRequest() noexcept { +} + +AddForeignKeyRequest::AddForeignKeyRequest() noexcept { +} + +void AddForeignKeyRequest::__set_foreignKeyCols(const std::vector & val) { + this->foreignKeyCols = val; +} +std::ostream& operator<<(std::ostream& out, const AddForeignKeyRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AddForeignKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_foreignKeyCols = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->foreignKeyCols.clear(); + uint32_t _size595; + ::apache::thrift::protocol::TType _etype598; + xfer += iprot->readListBegin(_etype598, _size595); + this->foreignKeyCols.resize(_size595); + uint32_t _i599; + for (_i599 = 0; _i599 < _size595; ++_i599) + { + xfer += this->foreignKeyCols[_i599].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_foreignKeyCols = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_foreignKeyCols) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AddForeignKeyRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AddForeignKeyRequest"); + + xfer += oprot->writeFieldBegin("foreignKeyCols", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->foreignKeyCols.size())); + std::vector ::const_iterator _iter600; + for (_iter600 = this->foreignKeyCols.begin(); _iter600 != this->foreignKeyCols.end(); ++_iter600) + { + xfer += (*_iter600).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AddForeignKeyRequest &a, AddForeignKeyRequest &b) noexcept { + using ::std::swap; + swap(a.foreignKeyCols, b.foreignKeyCols); +} + +bool AddForeignKeyRequest::operator==(const AddForeignKeyRequest & rhs) const +{ + if (!(foreignKeyCols == rhs.foreignKeyCols)) + return false; + return true; +} + +AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& other601) { + foreignKeyCols = other601.foreignKeyCols; +} +AddForeignKeyRequest& AddForeignKeyRequest::operator=(const AddForeignKeyRequest& other602) { + foreignKeyCols = other602.foreignKeyCols; + return *this; +} +void AddForeignKeyRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AddForeignKeyRequest("; + out << "foreignKeyCols=" << to_string(foreignKeyCols); + out << ")"; +} + + +AddUniqueConstraintRequest::~AddUniqueConstraintRequest() noexcept { +} + +AddUniqueConstraintRequest::AddUniqueConstraintRequest() noexcept { +} + +void AddUniqueConstraintRequest::__set_uniqueConstraintCols(const std::vector & val) { + this->uniqueConstraintCols = val; +} +std::ostream& operator<<(std::ostream& out, const AddUniqueConstraintRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AddUniqueConstraintRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_uniqueConstraintCols = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->uniqueConstraintCols.clear(); + uint32_t _size603; + ::apache::thrift::protocol::TType _etype606; + xfer += iprot->readListBegin(_etype606, _size603); + this->uniqueConstraintCols.resize(_size603); + uint32_t _i607; + for (_i607 = 0; _i607 < _size603; ++_i607) + { + xfer += this->uniqueConstraintCols[_i607].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_uniqueConstraintCols = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_uniqueConstraintCols) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AddUniqueConstraintRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AddUniqueConstraintRequest"); + + xfer += oprot->writeFieldBegin("uniqueConstraintCols", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->uniqueConstraintCols.size())); + std::vector ::const_iterator _iter608; + for (_iter608 = this->uniqueConstraintCols.begin(); _iter608 != this->uniqueConstraintCols.end(); ++_iter608) + { + xfer += (*_iter608).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AddUniqueConstraintRequest &a, AddUniqueConstraintRequest &b) noexcept { + using ::std::swap; + swap(a.uniqueConstraintCols, b.uniqueConstraintCols); +} + +bool AddUniqueConstraintRequest::operator==(const AddUniqueConstraintRequest & rhs) const +{ + if (!(uniqueConstraintCols == rhs.uniqueConstraintCols)) + return false; + return true; +} + +AddUniqueConstraintRequest::AddUniqueConstraintRequest(const AddUniqueConstraintRequest& other609) { + uniqueConstraintCols = other609.uniqueConstraintCols; +} +AddUniqueConstraintRequest& AddUniqueConstraintRequest::operator=(const AddUniqueConstraintRequest& other610) { + uniqueConstraintCols = other610.uniqueConstraintCols; + return *this; +} +void AddUniqueConstraintRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AddUniqueConstraintRequest("; + out << "uniqueConstraintCols=" << to_string(uniqueConstraintCols); + out << ")"; +} + + +AddNotNullConstraintRequest::~AddNotNullConstraintRequest() noexcept { +} + +AddNotNullConstraintRequest::AddNotNullConstraintRequest() noexcept { +} + +void AddNotNullConstraintRequest::__set_notNullConstraintCols(const std::vector & val) { + this->notNullConstraintCols = val; +} +std::ostream& operator<<(std::ostream& out, const AddNotNullConstraintRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AddNotNullConstraintRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_notNullConstraintCols = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->notNullConstraintCols.clear(); + uint32_t _size611; + ::apache::thrift::protocol::TType _etype614; + xfer += iprot->readListBegin(_etype614, _size611); + this->notNullConstraintCols.resize(_size611); + uint32_t _i615; + for (_i615 = 0; _i615 < _size611; ++_i615) + { + xfer += this->notNullConstraintCols[_i615].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_notNullConstraintCols = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_notNullConstraintCols) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AddNotNullConstraintRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AddNotNullConstraintRequest"); + + xfer += oprot->writeFieldBegin("notNullConstraintCols", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->notNullConstraintCols.size())); + std::vector ::const_iterator _iter616; + for (_iter616 = this->notNullConstraintCols.begin(); _iter616 != this->notNullConstraintCols.end(); ++_iter616) + { + xfer += (*_iter616).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AddNotNullConstraintRequest &a, AddNotNullConstraintRequest &b) noexcept { + using ::std::swap; + swap(a.notNullConstraintCols, b.notNullConstraintCols); +} + +bool AddNotNullConstraintRequest::operator==(const AddNotNullConstraintRequest & rhs) const +{ + if (!(notNullConstraintCols == rhs.notNullConstraintCols)) + return false; + return true; +} + +AddNotNullConstraintRequest::AddNotNullConstraintRequest(const AddNotNullConstraintRequest& other617) { + notNullConstraintCols = other617.notNullConstraintCols; +} +AddNotNullConstraintRequest& AddNotNullConstraintRequest::operator=(const AddNotNullConstraintRequest& other618) { + notNullConstraintCols = other618.notNullConstraintCols; + return *this; +} +void AddNotNullConstraintRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AddNotNullConstraintRequest("; + out << "notNullConstraintCols=" << to_string(notNullConstraintCols); + out << ")"; +} + + +AddDefaultConstraintRequest::~AddDefaultConstraintRequest() noexcept { +} + +AddDefaultConstraintRequest::AddDefaultConstraintRequest() noexcept { +} + +void AddDefaultConstraintRequest::__set_defaultConstraintCols(const std::vector & val) { + this->defaultConstraintCols = val; +} +std::ostream& operator<<(std::ostream& out, const AddDefaultConstraintRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AddDefaultConstraintRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_defaultConstraintCols = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->defaultConstraintCols.clear(); + uint32_t _size619; + ::apache::thrift::protocol::TType _etype622; + xfer += iprot->readListBegin(_etype622, _size619); + this->defaultConstraintCols.resize(_size619); + uint32_t _i623; + for (_i623 = 0; _i623 < _size619; ++_i623) + { + xfer += this->defaultConstraintCols[_i623].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_defaultConstraintCols = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_defaultConstraintCols) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AddDefaultConstraintRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AddDefaultConstraintRequest"); + + xfer += oprot->writeFieldBegin("defaultConstraintCols", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->defaultConstraintCols.size())); + std::vector ::const_iterator _iter624; + for (_iter624 = this->defaultConstraintCols.begin(); _iter624 != this->defaultConstraintCols.end(); ++_iter624) + { + xfer += (*_iter624).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AddDefaultConstraintRequest &a, AddDefaultConstraintRequest &b) noexcept { + using ::std::swap; + swap(a.defaultConstraintCols, b.defaultConstraintCols); +} + +bool AddDefaultConstraintRequest::operator==(const AddDefaultConstraintRequest & rhs) const +{ + if (!(defaultConstraintCols == rhs.defaultConstraintCols)) + return false; + return true; +} + +AddDefaultConstraintRequest::AddDefaultConstraintRequest(const AddDefaultConstraintRequest& other625) { + defaultConstraintCols = other625.defaultConstraintCols; +} +AddDefaultConstraintRequest& AddDefaultConstraintRequest::operator=(const AddDefaultConstraintRequest& other626) { + defaultConstraintCols = other626.defaultConstraintCols; + return *this; +} +void AddDefaultConstraintRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AddDefaultConstraintRequest("; + out << "defaultConstraintCols=" << to_string(defaultConstraintCols); + out << ")"; +} + + +AddCheckConstraintRequest::~AddCheckConstraintRequest() noexcept { +} + +AddCheckConstraintRequest::AddCheckConstraintRequest() noexcept { +} + +void AddCheckConstraintRequest::__set_checkConstraintCols(const std::vector & val) { + this->checkConstraintCols = val; +} +std::ostream& operator<<(std::ostream& out, const AddCheckConstraintRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AddCheckConstraintRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_checkConstraintCols = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->checkConstraintCols.clear(); + uint32_t _size627; + ::apache::thrift::protocol::TType _etype630; + xfer += iprot->readListBegin(_etype630, _size627); + this->checkConstraintCols.resize(_size627); + uint32_t _i631; + for (_i631 = 0; _i631 < _size627; ++_i631) + { + xfer += this->checkConstraintCols[_i631].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_checkConstraintCols = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_checkConstraintCols) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AddCheckConstraintRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AddCheckConstraintRequest"); + + xfer += oprot->writeFieldBegin("checkConstraintCols", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->checkConstraintCols.size())); + std::vector ::const_iterator _iter632; + for (_iter632 = this->checkConstraintCols.begin(); _iter632 != this->checkConstraintCols.end(); ++_iter632) + { + xfer += (*_iter632).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AddCheckConstraintRequest &a, AddCheckConstraintRequest &b) noexcept { + using ::std::swap; + swap(a.checkConstraintCols, b.checkConstraintCols); +} + +bool AddCheckConstraintRequest::operator==(const AddCheckConstraintRequest & rhs) const +{ + if (!(checkConstraintCols == rhs.checkConstraintCols)) + return false; + return true; +} + +AddCheckConstraintRequest::AddCheckConstraintRequest(const AddCheckConstraintRequest& other633) { + checkConstraintCols = other633.checkConstraintCols; +} +AddCheckConstraintRequest& AddCheckConstraintRequest::operator=(const AddCheckConstraintRequest& other634) { + checkConstraintCols = other634.checkConstraintCols; + return *this; +} +void AddCheckConstraintRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AddCheckConstraintRequest("; + out << "checkConstraintCols=" << to_string(checkConstraintCols); + out << ")"; +} + + +PartitionsByExprResult::~PartitionsByExprResult() noexcept { +} + +PartitionsByExprResult::PartitionsByExprResult() noexcept + : hasUnknownPartitions(0) { +} + +void PartitionsByExprResult::__set_partitions(const std::vector & val) { + this->partitions = val; +} + +void PartitionsByExprResult::__set_hasUnknownPartitions(const bool val) { + this->hasUnknownPartitions = val; +} +std::ostream& operator<<(std::ostream& out, const PartitionsByExprResult& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PartitionsByExprResult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_partitions = false; + bool isset_hasUnknownPartitions = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitions.clear(); + uint32_t _size635; + ::apache::thrift::protocol::TType _etype638; + xfer += iprot->readListBegin(_etype638, _size635); + this->partitions.resize(_size635); + uint32_t _i639; + for (_i639 = 0; _i639 < _size635; ++_i639) + { + xfer += this->partitions[_i639].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_partitions = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->hasUnknownPartitions); + isset_hasUnknownPartitions = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_partitions) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_hasUnknownPartitions) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t PartitionsByExprResult::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PartitionsByExprResult"); + + xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); + std::vector ::const_iterator _iter640; + for (_iter640 = this->partitions.begin(); _iter640 != this->partitions.end(); ++_iter640) + { + xfer += (*_iter640).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("hasUnknownPartitions", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool(this->hasUnknownPartitions); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PartitionsByExprResult &a, PartitionsByExprResult &b) noexcept { + using ::std::swap; + swap(a.partitions, b.partitions); + swap(a.hasUnknownPartitions, b.hasUnknownPartitions); +} + +bool PartitionsByExprResult::operator==(const PartitionsByExprResult & rhs) const +{ + if (!(partitions == rhs.partitions)) + return false; + if (!(hasUnknownPartitions == rhs.hasUnknownPartitions)) + return false; + return true; +} + +PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other641) { + partitions = other641.partitions; + hasUnknownPartitions = other641.hasUnknownPartitions; +} +PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other642) { + partitions = other642.partitions; + hasUnknownPartitions = other642.hasUnknownPartitions; + return *this; +} +void PartitionsByExprResult::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PartitionsByExprResult("; + out << "partitions=" << to_string(partitions); + out << ", " << "hasUnknownPartitions=" << to_string(hasUnknownPartitions); + out << ")"; +} + + +PartitionsSpecByExprResult::~PartitionsSpecByExprResult() noexcept { +} + +PartitionsSpecByExprResult::PartitionsSpecByExprResult() noexcept + : hasUnknownPartitions(0) { +} + +void PartitionsSpecByExprResult::__set_partitionsSpec(const std::vector & val) { + this->partitionsSpec = val; +} + +void PartitionsSpecByExprResult::__set_hasUnknownPartitions(const bool val) { + this->hasUnknownPartitions = val; +} +std::ostream& operator<<(std::ostream& out, const PartitionsSpecByExprResult& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PartitionsSpecByExprResult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_partitionsSpec = false; + bool isset_hasUnknownPartitions = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitionsSpec.clear(); + uint32_t _size643; + ::apache::thrift::protocol::TType _etype646; + xfer += iprot->readListBegin(_etype646, _size643); + this->partitionsSpec.resize(_size643); + uint32_t _i647; + for (_i647 = 0; _i647 < _size643; ++_i647) + { + xfer += this->partitionsSpec[_i647].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_partitionsSpec = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->hasUnknownPartitions); + isset_hasUnknownPartitions = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_partitionsSpec) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_hasUnknownPartitions) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t PartitionsSpecByExprResult::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PartitionsSpecByExprResult"); + + xfer += oprot->writeFieldBegin("partitionsSpec", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionsSpec.size())); + std::vector ::const_iterator _iter648; + for (_iter648 = this->partitionsSpec.begin(); _iter648 != this->partitionsSpec.end(); ++_iter648) + { + xfer += (*_iter648).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("hasUnknownPartitions", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool(this->hasUnknownPartitions); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PartitionsSpecByExprResult &a, PartitionsSpecByExprResult &b) noexcept { + using ::std::swap; + swap(a.partitionsSpec, b.partitionsSpec); + swap(a.hasUnknownPartitions, b.hasUnknownPartitions); +} + +bool PartitionsSpecByExprResult::operator==(const PartitionsSpecByExprResult & rhs) const +{ + if (!(partitionsSpec == rhs.partitionsSpec)) + return false; + if (!(hasUnknownPartitions == rhs.hasUnknownPartitions)) + return false; + return true; +} + +PartitionsSpecByExprResult::PartitionsSpecByExprResult(const PartitionsSpecByExprResult& other649) { + partitionsSpec = other649.partitionsSpec; + hasUnknownPartitions = other649.hasUnknownPartitions; +} +PartitionsSpecByExprResult& PartitionsSpecByExprResult::operator=(const PartitionsSpecByExprResult& other650) { + partitionsSpec = other650.partitionsSpec; + hasUnknownPartitions = other650.hasUnknownPartitions; + return *this; +} +void PartitionsSpecByExprResult::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PartitionsSpecByExprResult("; + out << "partitionsSpec=" << to_string(partitionsSpec); + out << ", " << "hasUnknownPartitions=" << to_string(hasUnknownPartitions); + out << ")"; +} + + +PartitionsByExprRequest::~PartitionsByExprRequest() noexcept { +} + +PartitionsByExprRequest::PartitionsByExprRequest() noexcept + : dbName(), + tblName(), + expr(), + defaultPartitionName(), + maxParts(-1), + catName(), + order(), + validWriteIdList(), + id(-1LL), + skipColumnSchemaForPartition(0), + includeParamKeyPattern(), + excludeParamKeyPattern() { +} + +void PartitionsByExprRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void PartitionsByExprRequest::__set_tblName(const std::string& val) { + this->tblName = val; +} + +void PartitionsByExprRequest::__set_expr(const std::string& val) { + this->expr = val; +} + +void PartitionsByExprRequest::__set_defaultPartitionName(const std::string& val) { + this->defaultPartitionName = val; +__isset.defaultPartitionName = true; +} + +void PartitionsByExprRequest::__set_maxParts(const int16_t val) { + this->maxParts = val; +__isset.maxParts = true; +} + +void PartitionsByExprRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void PartitionsByExprRequest::__set_order(const std::string& val) { + this->order = val; +__isset.order = true; +} + +void PartitionsByExprRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void PartitionsByExprRequest::__set_id(const int64_t val) { + this->id = val; +__isset.id = true; +} + +void PartitionsByExprRequest::__set_skipColumnSchemaForPartition(const bool val) { + this->skipColumnSchemaForPartition = val; +__isset.skipColumnSchemaForPartition = true; +} + +void PartitionsByExprRequest::__set_includeParamKeyPattern(const std::string& val) { + this->includeParamKeyPattern = val; +__isset.includeParamKeyPattern = true; +} + +void PartitionsByExprRequest::__set_excludeParamKeyPattern(const std::string& val) { + this->excludeParamKeyPattern = val; +__isset.excludeParamKeyPattern = true; +} +std::ostream& operator<<(std::ostream& out, const PartitionsByExprRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PartitionsByExprRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tblName = false; + bool isset_expr = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tblName); + isset_tblName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->expr); + isset_expr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->defaultPartitionName); + this->__isset.defaultPartitionName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I16) { + xfer += iprot->readI16(this->maxParts); + this->__isset.maxParts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->order); + this->__isset.order = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->id); + this->__isset.id = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->skipColumnSchemaForPartition); + this->__isset.skipColumnSchemaForPartition = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 11: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->includeParamKeyPattern); + this->__isset.includeParamKeyPattern = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 12: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->excludeParamKeyPattern); + this->__isset.excludeParamKeyPattern = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tblName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_expr) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t PartitionsByExprRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PartitionsByExprRequest"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tblName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("expr", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeBinary(this->expr); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.defaultPartitionName) { + xfer += oprot->writeFieldBegin("defaultPartitionName", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->defaultPartitionName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.maxParts) { + xfer += oprot->writeFieldBegin("maxParts", ::apache::thrift::protocol::T_I16, 5); + xfer += oprot->writeI16(this->maxParts); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.order) { + xfer += oprot->writeFieldBegin("order", ::apache::thrift::protocol::T_STRING, 7); + xfer += oprot->writeString(this->order); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 8); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.id) { + xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I64, 9); + xfer += oprot->writeI64(this->id); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.skipColumnSchemaForPartition) { + xfer += oprot->writeFieldBegin("skipColumnSchemaForPartition", ::apache::thrift::protocol::T_BOOL, 10); + xfer += oprot->writeBool(this->skipColumnSchemaForPartition); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.includeParamKeyPattern) { + xfer += oprot->writeFieldBegin("includeParamKeyPattern", ::apache::thrift::protocol::T_STRING, 11); + xfer += oprot->writeString(this->includeParamKeyPattern); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.excludeParamKeyPattern) { + xfer += oprot->writeFieldBegin("excludeParamKeyPattern", ::apache::thrift::protocol::T_STRING, 12); + xfer += oprot->writeString(this->excludeParamKeyPattern); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PartitionsByExprRequest &a, PartitionsByExprRequest &b) noexcept { + using ::std::swap; + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); + swap(a.expr, b.expr); + swap(a.defaultPartitionName, b.defaultPartitionName); + swap(a.maxParts, b.maxParts); + swap(a.catName, b.catName); + swap(a.order, b.order); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.id, b.id); + swap(a.skipColumnSchemaForPartition, b.skipColumnSchemaForPartition); + swap(a.includeParamKeyPattern, b.includeParamKeyPattern); + swap(a.excludeParamKeyPattern, b.excludeParamKeyPattern); + swap(a.__isset, b.__isset); +} + +bool PartitionsByExprRequest::operator==(const PartitionsByExprRequest & rhs) const +{ + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + if (!(expr == rhs.expr)) + return false; + if (__isset.defaultPartitionName != rhs.__isset.defaultPartitionName) + return false; + else if (__isset.defaultPartitionName && !(defaultPartitionName == rhs.defaultPartitionName)) + return false; + if (__isset.maxParts != rhs.__isset.maxParts) + return false; + else if (__isset.maxParts && !(maxParts == rhs.maxParts)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (__isset.order != rhs.__isset.order) + return false; + else if (__isset.order && !(order == rhs.order)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.id != rhs.__isset.id) + return false; + else if (__isset.id && !(id == rhs.id)) + return false; + if (__isset.skipColumnSchemaForPartition != rhs.__isset.skipColumnSchemaForPartition) + return false; + else if (__isset.skipColumnSchemaForPartition && !(skipColumnSchemaForPartition == rhs.skipColumnSchemaForPartition)) + return false; + if (__isset.includeParamKeyPattern != rhs.__isset.includeParamKeyPattern) + return false; + else if (__isset.includeParamKeyPattern && !(includeParamKeyPattern == rhs.includeParamKeyPattern)) + return false; + if (__isset.excludeParamKeyPattern != rhs.__isset.excludeParamKeyPattern) + return false; + else if (__isset.excludeParamKeyPattern && !(excludeParamKeyPattern == rhs.excludeParamKeyPattern)) + return false; + return true; +} + +PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other651) { + dbName = other651.dbName; + tblName = other651.tblName; + expr = other651.expr; + defaultPartitionName = other651.defaultPartitionName; + maxParts = other651.maxParts; + catName = other651.catName; + order = other651.order; + validWriteIdList = other651.validWriteIdList; + id = other651.id; + skipColumnSchemaForPartition = other651.skipColumnSchemaForPartition; + includeParamKeyPattern = other651.includeParamKeyPattern; + excludeParamKeyPattern = other651.excludeParamKeyPattern; + __isset = other651.__isset; +} +PartitionsByExprRequest& PartitionsByExprRequest::operator=(const PartitionsByExprRequest& other652) { + dbName = other652.dbName; + tblName = other652.tblName; + expr = other652.expr; + defaultPartitionName = other652.defaultPartitionName; + maxParts = other652.maxParts; + catName = other652.catName; + order = other652.order; + validWriteIdList = other652.validWriteIdList; + id = other652.id; + skipColumnSchemaForPartition = other652.skipColumnSchemaForPartition; + includeParamKeyPattern = other652.includeParamKeyPattern; + excludeParamKeyPattern = other652.excludeParamKeyPattern; + __isset = other652.__isset; + return *this; +} +void PartitionsByExprRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PartitionsByExprRequest("; + out << "dbName=" << to_string(dbName); + out << ", " << "tblName=" << to_string(tblName); + out << ", " << "expr=" << to_string(expr); + out << ", " << "defaultPartitionName="; (__isset.defaultPartitionName ? (out << to_string(defaultPartitionName)) : (out << "")); + out << ", " << "maxParts="; (__isset.maxParts ? (out << to_string(maxParts)) : (out << "")); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "order="; (__isset.order ? (out << to_string(order)) : (out << "")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "id="; (__isset.id ? (out << to_string(id)) : (out << "")); + out << ", " << "skipColumnSchemaForPartition="; (__isset.skipColumnSchemaForPartition ? (out << to_string(skipColumnSchemaForPartition)) : (out << "")); + out << ", " << "includeParamKeyPattern="; (__isset.includeParamKeyPattern ? (out << to_string(includeParamKeyPattern)) : (out << "")); + out << ", " << "excludeParamKeyPattern="; (__isset.excludeParamKeyPattern ? (out << to_string(excludeParamKeyPattern)) : (out << "")); + out << ")"; +} + + +TableStatsResult::~TableStatsResult() noexcept { +} + +TableStatsResult::TableStatsResult() noexcept + : isStatsCompliant(0) { +} + +void TableStatsResult::__set_tableStats(const std::vector & val) { + this->tableStats = val; +} + +void TableStatsResult::__set_isStatsCompliant(const bool val) { + this->isStatsCompliant = val; +__isset.isStatsCompliant = true; +} +std::ostream& operator<<(std::ostream& out, const TableStatsResult& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t TableStatsResult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_tableStats = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->tableStats.clear(); + uint32_t _size653; + ::apache::thrift::protocol::TType _etype656; + xfer += iprot->readListBegin(_etype656, _size653); + this->tableStats.resize(_size653); + uint32_t _i657; + for (_i657 = 0; _i657 < _size653; ++_i657) + { + xfer += this->tableStats[_i657].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_tableStats = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isStatsCompliant); + this->__isset.isStatsCompliant = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_tableStats) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t TableStatsResult::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("TableStatsResult"); + + xfer += oprot->writeFieldBegin("tableStats", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->tableStats.size())); + std::vector ::const_iterator _iter658; + for (_iter658 = this->tableStats.begin(); _iter658 != this->tableStats.end(); ++_iter658) + { + xfer += (*_iter658).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.isStatsCompliant) { + xfer += oprot->writeFieldBegin("isStatsCompliant", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool(this->isStatsCompliant); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(TableStatsResult &a, TableStatsResult &b) noexcept { + using ::std::swap; + swap(a.tableStats, b.tableStats); + swap(a.isStatsCompliant, b.isStatsCompliant); + swap(a.__isset, b.__isset); +} + +bool TableStatsResult::operator==(const TableStatsResult & rhs) const +{ + if (!(tableStats == rhs.tableStats)) + return false; + if (__isset.isStatsCompliant != rhs.__isset.isStatsCompliant) + return false; + else if (__isset.isStatsCompliant && !(isStatsCompliant == rhs.isStatsCompliant)) + return false; + return true; +} + +TableStatsResult::TableStatsResult(const TableStatsResult& other659) { + tableStats = other659.tableStats; + isStatsCompliant = other659.isStatsCompliant; + __isset = other659.__isset; +} +TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other660) { + tableStats = other660.tableStats; + isStatsCompliant = other660.isStatsCompliant; + __isset = other660.__isset; + return *this; +} +void TableStatsResult::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "TableStatsResult("; + out << "tableStats=" << to_string(tableStats); + out << ", " << "isStatsCompliant="; (__isset.isStatsCompliant ? (out << to_string(isStatsCompliant)) : (out << "")); + out << ")"; +} + + +PartitionsStatsResult::~PartitionsStatsResult() noexcept { +} + +PartitionsStatsResult::PartitionsStatsResult() noexcept + : isStatsCompliant(0) { +} + +void PartitionsStatsResult::__set_partStats(const std::map > & val) { + this->partStats = val; +} + +void PartitionsStatsResult::__set_isStatsCompliant(const bool val) { + this->isStatsCompliant = val; +__isset.isStatsCompliant = true; +} +std::ostream& operator<<(std::ostream& out, const PartitionsStatsResult& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PartitionsStatsResult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_partStats = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->partStats.clear(); + uint32_t _size661; + ::apache::thrift::protocol::TType _ktype662; + ::apache::thrift::protocol::TType _vtype663; + xfer += iprot->readMapBegin(_ktype662, _vtype663, _size661); + uint32_t _i665; + for (_i665 = 0; _i665 < _size661; ++_i665) + { + std::string _key666; + xfer += iprot->readString(_key666); + std::vector & _val667 = this->partStats[_key666]; + { + _val667.clear(); + uint32_t _size668; + ::apache::thrift::protocol::TType _etype671; + xfer += iprot->readListBegin(_etype671, _size668); + _val667.resize(_size668); + uint32_t _i672; + for (_i672 = 0; _i672 < _size668; ++_i672) + { + xfer += _val667[_i672].read(iprot); + } + xfer += iprot->readListEnd(); + } + } + xfer += iprot->readMapEnd(); + } + isset_partStats = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isStatsCompliant); + this->__isset.isStatsCompliant = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_partStats) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t PartitionsStatsResult::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PartitionsStatsResult"); + + xfer += oprot->writeFieldBegin("partStats", ::apache::thrift::protocol::T_MAP, 1); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast(this->partStats.size())); + std::map > ::const_iterator _iter673; + for (_iter673 = this->partStats.begin(); _iter673 != this->partStats.end(); ++_iter673) + { + xfer += oprot->writeString(_iter673->first); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter673->second.size())); + std::vector ::const_iterator _iter674; + for (_iter674 = _iter673->second.begin(); _iter674 != _iter673->second.end(); ++_iter674) + { + xfer += (*_iter674).write(oprot); + } + xfer += oprot->writeListEnd(); + } + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.isStatsCompliant) { + xfer += oprot->writeFieldBegin("isStatsCompliant", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool(this->isStatsCompliant); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PartitionsStatsResult &a, PartitionsStatsResult &b) noexcept { + using ::std::swap; + swap(a.partStats, b.partStats); + swap(a.isStatsCompliant, b.isStatsCompliant); + swap(a.__isset, b.__isset); +} + +bool PartitionsStatsResult::operator==(const PartitionsStatsResult & rhs) const +{ + if (!(partStats == rhs.partStats)) + return false; + if (__isset.isStatsCompliant != rhs.__isset.isStatsCompliant) + return false; + else if (__isset.isStatsCompliant && !(isStatsCompliant == rhs.isStatsCompliant)) + return false; + return true; +} + +PartitionsStatsResult::PartitionsStatsResult(const PartitionsStatsResult& other675) { + partStats = other675.partStats; + isStatsCompliant = other675.isStatsCompliant; + __isset = other675.__isset; +} +PartitionsStatsResult& PartitionsStatsResult::operator=(const PartitionsStatsResult& other676) { + partStats = other676.partStats; + isStatsCompliant = other676.isStatsCompliant; + __isset = other676.__isset; + return *this; +} +void PartitionsStatsResult::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PartitionsStatsResult("; + out << "partStats=" << to_string(partStats); + out << ", " << "isStatsCompliant="; (__isset.isStatsCompliant ? (out << to_string(isStatsCompliant)) : (out << "")); + out << ")"; +} + + +TableStatsRequest::~TableStatsRequest() noexcept { +} + +TableStatsRequest::TableStatsRequest() : dbName(), + tblName(), + catName(), + validWriteIdList(), + engine("hive"), + id(-1LL) { +} + +void TableStatsRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void TableStatsRequest::__set_tblName(const std::string& val) { + this->tblName = val; +} + +void TableStatsRequest::__set_colNames(const std::vector & val) { + this->colNames = val; +} + +void TableStatsRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void TableStatsRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void TableStatsRequest::__set_engine(const std::string& val) { + this->engine = val; +__isset.engine = true; +} + +void TableStatsRequest::__set_id(const int64_t val) { + this->id = val; +__isset.id = true; +} +std::ostream& operator<<(std::ostream& out, const TableStatsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t TableStatsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tblName = false; + bool isset_colNames = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tblName); + isset_tblName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->colNames.clear(); + uint32_t _size677; + ::apache::thrift::protocol::TType _etype680; + xfer += iprot->readListBegin(_etype680, _size677); + this->colNames.resize(_size677); + uint32_t _i681; + for (_i681 = 0; _i681 < _size677; ++_i681) + { + xfer += iprot->readString(this->colNames[_i681]); + } + xfer += iprot->readListEnd(); + } + isset_colNames = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->engine); + this->__isset.engine = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->id); + this->__isset.id = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tblName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_colNames) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t TableStatsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("TableStatsRequest"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tblName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("colNames", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->colNames.size())); + std::vector ::const_iterator _iter682; + for (_iter682 = this->colNames.begin(); _iter682 != this->colNames.end(); ++_iter682) + { + xfer += oprot->writeString((*_iter682)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.engine) { + xfer += oprot->writeFieldBegin("engine", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->engine); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.id) { + xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I64, 7); + xfer += oprot->writeI64(this->id); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(TableStatsRequest &a, TableStatsRequest &b) noexcept { + using ::std::swap; + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); + swap(a.colNames, b.colNames); + swap(a.catName, b.catName); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.engine, b.engine); + swap(a.id, b.id); + swap(a.__isset, b.__isset); +} + +bool TableStatsRequest::operator==(const TableStatsRequest & rhs) const +{ + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + if (!(colNames == rhs.colNames)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.engine != rhs.__isset.engine) + return false; + else if (__isset.engine && !(engine == rhs.engine)) + return false; + if (__isset.id != rhs.__isset.id) + return false; + else if (__isset.id && !(id == rhs.id)) + return false; + return true; +} + +TableStatsRequest::TableStatsRequest(const TableStatsRequest& other683) { + dbName = other683.dbName; + tblName = other683.tblName; + colNames = other683.colNames; + catName = other683.catName; + validWriteIdList = other683.validWriteIdList; + engine = other683.engine; + id = other683.id; + __isset = other683.__isset; +} +TableStatsRequest& TableStatsRequest::operator=(const TableStatsRequest& other684) { + dbName = other684.dbName; + tblName = other684.tblName; + colNames = other684.colNames; + catName = other684.catName; + validWriteIdList = other684.validWriteIdList; + engine = other684.engine; + id = other684.id; + __isset = other684.__isset; + return *this; +} +void TableStatsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "TableStatsRequest("; + out << "dbName=" << to_string(dbName); + out << ", " << "tblName=" << to_string(tblName); + out << ", " << "colNames=" << to_string(colNames); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "engine="; (__isset.engine ? (out << to_string(engine)) : (out << "")); + out << ", " << "id="; (__isset.id ? (out << to_string(id)) : (out << "")); + out << ")"; +} + + +PartitionsStatsRequest::~PartitionsStatsRequest() noexcept { +} + +PartitionsStatsRequest::PartitionsStatsRequest() : dbName(), + tblName(), + catName(), + validWriteIdList(), + engine("hive") { +} + +void PartitionsStatsRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void PartitionsStatsRequest::__set_tblName(const std::string& val) { + this->tblName = val; +} + +void PartitionsStatsRequest::__set_colNames(const std::vector & val) { + this->colNames = val; +} + +void PartitionsStatsRequest::__set_partNames(const std::vector & val) { + this->partNames = val; +} + +void PartitionsStatsRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void PartitionsStatsRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void PartitionsStatsRequest::__set_engine(const std::string& val) { + this->engine = val; +__isset.engine = true; +} +std::ostream& operator<<(std::ostream& out, const PartitionsStatsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tblName = false; + bool isset_colNames = false; + bool isset_partNames = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tblName); + isset_tblName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->colNames.clear(); + uint32_t _size685; + ::apache::thrift::protocol::TType _etype688; + xfer += iprot->readListBegin(_etype688, _size685); + this->colNames.resize(_size685); + uint32_t _i689; + for (_i689 = 0; _i689 < _size685; ++_i689) + { + xfer += iprot->readString(this->colNames[_i689]); + } + xfer += iprot->readListEnd(); + } + isset_colNames = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partNames.clear(); + uint32_t _size690; + ::apache::thrift::protocol::TType _etype693; + xfer += iprot->readListBegin(_etype693, _size690); + this->partNames.resize(_size690); + uint32_t _i694; + for (_i694 = 0; _i694 < _size690; ++_i694) + { + xfer += iprot->readString(this->partNames[_i694]); + } + xfer += iprot->readListEnd(); + } + isset_partNames = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->engine); + this->__isset.engine = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tblName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_colNames) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_partNames) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t PartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PartitionsStatsRequest"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tblName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("colNames", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->colNames.size())); + std::vector ::const_iterator _iter695; + for (_iter695 = this->colNames.begin(); _iter695 != this->colNames.end(); ++_iter695) + { + xfer += oprot->writeString((*_iter695)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partNames.size())); + std::vector ::const_iterator _iter696; + for (_iter696 = this->partNames.begin(); _iter696 != this->partNames.end(); ++_iter696) + { + xfer += oprot->writeString((*_iter696)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.engine) { + xfer += oprot->writeFieldBegin("engine", ::apache::thrift::protocol::T_STRING, 7); + xfer += oprot->writeString(this->engine); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PartitionsStatsRequest &a, PartitionsStatsRequest &b) noexcept { + using ::std::swap; + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); + swap(a.colNames, b.colNames); + swap(a.partNames, b.partNames); + swap(a.catName, b.catName); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.engine, b.engine); + swap(a.__isset, b.__isset); +} + +bool PartitionsStatsRequest::operator==(const PartitionsStatsRequest & rhs) const +{ + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + if (!(colNames == rhs.colNames)) + return false; + if (!(partNames == rhs.partNames)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.engine != rhs.__isset.engine) + return false; + else if (__isset.engine && !(engine == rhs.engine)) + return false; + return true; +} + +PartitionsStatsRequest::PartitionsStatsRequest(const PartitionsStatsRequest& other697) { + dbName = other697.dbName; + tblName = other697.tblName; + colNames = other697.colNames; + partNames = other697.partNames; + catName = other697.catName; + validWriteIdList = other697.validWriteIdList; + engine = other697.engine; + __isset = other697.__isset; +} +PartitionsStatsRequest& PartitionsStatsRequest::operator=(const PartitionsStatsRequest& other698) { + dbName = other698.dbName; + tblName = other698.tblName; + colNames = other698.colNames; + partNames = other698.partNames; + catName = other698.catName; + validWriteIdList = other698.validWriteIdList; + engine = other698.engine; + __isset = other698.__isset; + return *this; +} +void PartitionsStatsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PartitionsStatsRequest("; + out << "dbName=" << to_string(dbName); + out << ", " << "tblName=" << to_string(tblName); + out << ", " << "colNames=" << to_string(colNames); + out << ", " << "partNames=" << to_string(partNames); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "engine="; (__isset.engine ? (out << to_string(engine)) : (out << "")); + out << ")"; +} + + +AddPartitionsResult::~AddPartitionsResult() noexcept { +} + +AddPartitionsResult::AddPartitionsResult() noexcept + : isStatsCompliant(0) { +} + +void AddPartitionsResult::__set_partitions(const std::vector & val) { + this->partitions = val; +__isset.partitions = true; +} + +void AddPartitionsResult::__set_isStatsCompliant(const bool val) { + this->isStatsCompliant = val; +__isset.isStatsCompliant = true; +} + +void AddPartitionsResult::__set_partitionColSchema(const std::vector & val) { + this->partitionColSchema = val; +__isset.partitionColSchema = true; +} +std::ostream& operator<<(std::ostream& out, const AddPartitionsResult& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AddPartitionsResult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitions.clear(); + uint32_t _size699; + ::apache::thrift::protocol::TType _etype702; + xfer += iprot->readListBegin(_etype702, _size699); + this->partitions.resize(_size699); + uint32_t _i703; + for (_i703 = 0; _i703 < _size699; ++_i703) + { + xfer += this->partitions[_i703].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.partitions = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isStatsCompliant); + this->__isset.isStatsCompliant = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitionColSchema.clear(); + uint32_t _size704; + ::apache::thrift::protocol::TType _etype707; + xfer += iprot->readListBegin(_etype707, _size704); + this->partitionColSchema.resize(_size704); + uint32_t _i708; + for (_i708 = 0; _i708 < _size704; ++_i708) + { + xfer += this->partitionColSchema[_i708].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.partitionColSchema = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t AddPartitionsResult::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AddPartitionsResult"); + + if (this->__isset.partitions) { + xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); + std::vector ::const_iterator _iter709; + for (_iter709 = this->partitions.begin(); _iter709 != this->partitions.end(); ++_iter709) + { + xfer += (*_iter709).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.isStatsCompliant) { + xfer += oprot->writeFieldBegin("isStatsCompliant", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool(this->isStatsCompliant); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.partitionColSchema) { + xfer += oprot->writeFieldBegin("partitionColSchema", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionColSchema.size())); + std::vector ::const_iterator _iter710; + for (_iter710 = this->partitionColSchema.begin(); _iter710 != this->partitionColSchema.end(); ++_iter710) + { + xfer += (*_iter710).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AddPartitionsResult &a, AddPartitionsResult &b) noexcept { + using ::std::swap; + swap(a.partitions, b.partitions); + swap(a.isStatsCompliant, b.isStatsCompliant); + swap(a.partitionColSchema, b.partitionColSchema); + swap(a.__isset, b.__isset); +} + +bool AddPartitionsResult::operator==(const AddPartitionsResult & rhs) const +{ + if (__isset.partitions != rhs.__isset.partitions) + return false; + else if (__isset.partitions && !(partitions == rhs.partitions)) + return false; + if (__isset.isStatsCompliant != rhs.__isset.isStatsCompliant) + return false; + else if (__isset.isStatsCompliant && !(isStatsCompliant == rhs.isStatsCompliant)) + return false; + if (__isset.partitionColSchema != rhs.__isset.partitionColSchema) + return false; + else if (__isset.partitionColSchema && !(partitionColSchema == rhs.partitionColSchema)) + return false; + return true; +} + +AddPartitionsResult::AddPartitionsResult(const AddPartitionsResult& other711) { + partitions = other711.partitions; + isStatsCompliant = other711.isStatsCompliant; + partitionColSchema = other711.partitionColSchema; + __isset = other711.__isset; +} +AddPartitionsResult& AddPartitionsResult::operator=(const AddPartitionsResult& other712) { + partitions = other712.partitions; + isStatsCompliant = other712.isStatsCompliant; + partitionColSchema = other712.partitionColSchema; + __isset = other712.__isset; + return *this; +} +void AddPartitionsResult::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AddPartitionsResult("; + out << "partitions="; (__isset.partitions ? (out << to_string(partitions)) : (out << "")); + out << ", " << "isStatsCompliant="; (__isset.isStatsCompliant ? (out << to_string(isStatsCompliant)) : (out << "")); + out << ", " << "partitionColSchema="; (__isset.partitionColSchema ? (out << to_string(partitionColSchema)) : (out << "")); + out << ")"; +} + + +AddPartitionsRequest::~AddPartitionsRequest() noexcept { +} + +AddPartitionsRequest::AddPartitionsRequest() noexcept + : dbName(), + tblName(), + ifNotExists(0), + needResult(true), + catName(), + validWriteIdList(), + skipColumnSchemaForPartition(0) { +} + +void AddPartitionsRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void AddPartitionsRequest::__set_tblName(const std::string& val) { + this->tblName = val; +} + +void AddPartitionsRequest::__set_parts(const std::vector & val) { + this->parts = val; +} + +void AddPartitionsRequest::__set_ifNotExists(const bool val) { + this->ifNotExists = val; +} + +void AddPartitionsRequest::__set_needResult(const bool val) { + this->needResult = val; +__isset.needResult = true; +} + +void AddPartitionsRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void AddPartitionsRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void AddPartitionsRequest::__set_skipColumnSchemaForPartition(const bool val) { + this->skipColumnSchemaForPartition = val; +__isset.skipColumnSchemaForPartition = true; +} + +void AddPartitionsRequest::__set_partitionColSchema(const std::vector & val) { + this->partitionColSchema = val; +__isset.partitionColSchema = true; +} + +void AddPartitionsRequest::__set_environmentContext(const EnvironmentContext& val) { + this->environmentContext = val; +__isset.environmentContext = true; +} +std::ostream& operator<<(std::ostream& out, const AddPartitionsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AddPartitionsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tblName = false; + bool isset_parts = false; + bool isset_ifNotExists = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tblName); + isset_tblName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->parts.clear(); + uint32_t _size713; + ::apache::thrift::protocol::TType _etype716; + xfer += iprot->readListBegin(_etype716, _size713); + this->parts.resize(_size713); + uint32_t _i717; + for (_i717 = 0; _i717 < _size713; ++_i717) + { + xfer += this->parts[_i717].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_parts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->ifNotExists); + isset_ifNotExists = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->needResult); + this->__isset.needResult = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->skipColumnSchemaForPartition); + this->__isset.skipColumnSchemaForPartition = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitionColSchema.clear(); + uint32_t _size718; + ::apache::thrift::protocol::TType _etype721; + xfer += iprot->readListBegin(_etype721, _size718); + this->partitionColSchema.resize(_size718); + uint32_t _i722; + for (_i722 = 0; _i722 < _size718; ++_i722) + { + xfer += this->partitionColSchema[_i722].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.partitionColSchema = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->environmentContext.read(iprot); + this->__isset.environmentContext = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tblName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_parts) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_ifNotExists) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AddPartitionsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AddPartitionsRequest"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tblName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("parts", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->parts.size())); + std::vector ::const_iterator _iter723; + for (_iter723 = this->parts.begin(); _iter723 != this->parts.end(); ++_iter723) + { + xfer += (*_iter723).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("ifNotExists", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool(this->ifNotExists); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.needResult) { + xfer += oprot->writeFieldBegin("needResult", ::apache::thrift::protocol::T_BOOL, 5); + xfer += oprot->writeBool(this->needResult); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 7); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.skipColumnSchemaForPartition) { + xfer += oprot->writeFieldBegin("skipColumnSchemaForPartition", ::apache::thrift::protocol::T_BOOL, 8); + xfer += oprot->writeBool(this->skipColumnSchemaForPartition); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.partitionColSchema) { + xfer += oprot->writeFieldBegin("partitionColSchema", ::apache::thrift::protocol::T_LIST, 9); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionColSchema.size())); + std::vector ::const_iterator _iter724; + for (_iter724 = this->partitionColSchema.begin(); _iter724 != this->partitionColSchema.end(); ++_iter724) + { + xfer += (*_iter724).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.environmentContext) { + xfer += oprot->writeFieldBegin("environmentContext", ::apache::thrift::protocol::T_STRUCT, 10); + xfer += this->environmentContext.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AddPartitionsRequest &a, AddPartitionsRequest &b) noexcept { + using ::std::swap; + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); + swap(a.parts, b.parts); + swap(a.ifNotExists, b.ifNotExists); + swap(a.needResult, b.needResult); + swap(a.catName, b.catName); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.skipColumnSchemaForPartition, b.skipColumnSchemaForPartition); + swap(a.partitionColSchema, b.partitionColSchema); + swap(a.environmentContext, b.environmentContext); + swap(a.__isset, b.__isset); +} + +bool AddPartitionsRequest::operator==(const AddPartitionsRequest & rhs) const +{ + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + if (!(parts == rhs.parts)) + return false; + if (!(ifNotExists == rhs.ifNotExists)) + return false; + if (__isset.needResult != rhs.__isset.needResult) + return false; + else if (__isset.needResult && !(needResult == rhs.needResult)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.skipColumnSchemaForPartition != rhs.__isset.skipColumnSchemaForPartition) + return false; + else if (__isset.skipColumnSchemaForPartition && !(skipColumnSchemaForPartition == rhs.skipColumnSchemaForPartition)) + return false; + if (__isset.partitionColSchema != rhs.__isset.partitionColSchema) + return false; + else if (__isset.partitionColSchema && !(partitionColSchema == rhs.partitionColSchema)) + return false; + if (__isset.environmentContext != rhs.__isset.environmentContext) + return false; + else if (__isset.environmentContext && !(environmentContext == rhs.environmentContext)) + return false; + return true; +} + +AddPartitionsRequest::AddPartitionsRequest(const AddPartitionsRequest& other725) { + dbName = other725.dbName; + tblName = other725.tblName; + parts = other725.parts; + ifNotExists = other725.ifNotExists; + needResult = other725.needResult; + catName = other725.catName; + validWriteIdList = other725.validWriteIdList; + skipColumnSchemaForPartition = other725.skipColumnSchemaForPartition; + partitionColSchema = other725.partitionColSchema; + environmentContext = other725.environmentContext; + __isset = other725.__isset; +} +AddPartitionsRequest& AddPartitionsRequest::operator=(const AddPartitionsRequest& other726) { + dbName = other726.dbName; + tblName = other726.tblName; + parts = other726.parts; + ifNotExists = other726.ifNotExists; + needResult = other726.needResult; + catName = other726.catName; + validWriteIdList = other726.validWriteIdList; + skipColumnSchemaForPartition = other726.skipColumnSchemaForPartition; + partitionColSchema = other726.partitionColSchema; + environmentContext = other726.environmentContext; + __isset = other726.__isset; + return *this; +} +void AddPartitionsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AddPartitionsRequest("; + out << "dbName=" << to_string(dbName); + out << ", " << "tblName=" << to_string(tblName); + out << ", " << "parts=" << to_string(parts); + out << ", " << "ifNotExists=" << to_string(ifNotExists); + out << ", " << "needResult="; (__isset.needResult ? (out << to_string(needResult)) : (out << "")); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "skipColumnSchemaForPartition="; (__isset.skipColumnSchemaForPartition ? (out << to_string(skipColumnSchemaForPartition)) : (out << "")); + out << ", " << "partitionColSchema="; (__isset.partitionColSchema ? (out << to_string(partitionColSchema)) : (out << "")); + out << ", " << "environmentContext="; (__isset.environmentContext ? (out << to_string(environmentContext)) : (out << "")); + out << ")"; +} + + +DropPartitionsResult::~DropPartitionsResult() noexcept { +} + +DropPartitionsResult::DropPartitionsResult() noexcept { +} + +void DropPartitionsResult::__set_partitions(const std::vector & val) { + this->partitions = val; +__isset.partitions = true; +} +std::ostream& operator<<(std::ostream& out, const DropPartitionsResult& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t DropPartitionsResult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitions.clear(); + uint32_t _size727; + ::apache::thrift::protocol::TType _etype730; + xfer += iprot->readListBegin(_etype730, _size727); + this->partitions.resize(_size727); + uint32_t _i731; + for (_i731 = 0; _i731 < _size727; ++_i731) + { + xfer += this->partitions[_i731].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.partitions = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t DropPartitionsResult::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("DropPartitionsResult"); + + if (this->__isset.partitions) { + xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); + std::vector ::const_iterator _iter732; + for (_iter732 = this->partitions.begin(); _iter732 != this->partitions.end(); ++_iter732) + { + xfer += (*_iter732).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(DropPartitionsResult &a, DropPartitionsResult &b) noexcept { + using ::std::swap; + swap(a.partitions, b.partitions); + swap(a.__isset, b.__isset); +} + +bool DropPartitionsResult::operator==(const DropPartitionsResult & rhs) const +{ + if (__isset.partitions != rhs.__isset.partitions) + return false; + else if (__isset.partitions && !(partitions == rhs.partitions)) + return false; + return true; +} + +DropPartitionsResult::DropPartitionsResult(const DropPartitionsResult& other733) { + partitions = other733.partitions; + __isset = other733.__isset; +} +DropPartitionsResult& DropPartitionsResult::operator=(const DropPartitionsResult& other734) { + partitions = other734.partitions; + __isset = other734.__isset; + return *this; +} +void DropPartitionsResult::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "DropPartitionsResult("; + out << "partitions="; (__isset.partitions ? (out << to_string(partitions)) : (out << "")); + out << ")"; +} + + +DropPartitionsExpr::~DropPartitionsExpr() noexcept { +} + +DropPartitionsExpr::DropPartitionsExpr() noexcept + : expr(), + partArchiveLevel(0) { +} + +void DropPartitionsExpr::__set_expr(const std::string& val) { + this->expr = val; +} + +void DropPartitionsExpr::__set_partArchiveLevel(const int32_t val) { + this->partArchiveLevel = val; +__isset.partArchiveLevel = true; +} +std::ostream& operator<<(std::ostream& out, const DropPartitionsExpr& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t DropPartitionsExpr::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_expr = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->expr); + isset_expr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->partArchiveLevel); + this->__isset.partArchiveLevel = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_expr) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t DropPartitionsExpr::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("DropPartitionsExpr"); + + xfer += oprot->writeFieldBegin("expr", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeBinary(this->expr); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.partArchiveLevel) { + xfer += oprot->writeFieldBegin("partArchiveLevel", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(this->partArchiveLevel); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(DropPartitionsExpr &a, DropPartitionsExpr &b) noexcept { + using ::std::swap; + swap(a.expr, b.expr); + swap(a.partArchiveLevel, b.partArchiveLevel); + swap(a.__isset, b.__isset); +} + +bool DropPartitionsExpr::operator==(const DropPartitionsExpr & rhs) const +{ + if (!(expr == rhs.expr)) + return false; + if (__isset.partArchiveLevel != rhs.__isset.partArchiveLevel) + return false; + else if (__isset.partArchiveLevel && !(partArchiveLevel == rhs.partArchiveLevel)) + return false; + return true; +} + +DropPartitionsExpr::DropPartitionsExpr(const DropPartitionsExpr& other735) { + expr = other735.expr; + partArchiveLevel = other735.partArchiveLevel; + __isset = other735.__isset; +} +DropPartitionsExpr& DropPartitionsExpr::operator=(const DropPartitionsExpr& other736) { + expr = other736.expr; + partArchiveLevel = other736.partArchiveLevel; + __isset = other736.__isset; + return *this; +} +void DropPartitionsExpr::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "DropPartitionsExpr("; + out << "expr=" << to_string(expr); + out << ", " << "partArchiveLevel="; (__isset.partArchiveLevel ? (out << to_string(partArchiveLevel)) : (out << "")); + out << ")"; +} + + +RequestPartsSpec::~RequestPartsSpec() noexcept { +} + +RequestPartsSpec::RequestPartsSpec() noexcept { +} + +void RequestPartsSpec::__set_names(const std::vector & val) { + this->names = val; +__isset.names = true; +} + +void RequestPartsSpec::__set_exprs(const std::vector & val) { + this->exprs = val; +__isset.exprs = true; +} +std::ostream& operator<<(std::ostream& out, const RequestPartsSpec& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t RequestPartsSpec::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->names.clear(); + uint32_t _size737; + ::apache::thrift::protocol::TType _etype740; + xfer += iprot->readListBegin(_etype740, _size737); + this->names.resize(_size737); + uint32_t _i741; + for (_i741 = 0; _i741 < _size737; ++_i741) + { + xfer += iprot->readString(this->names[_i741]); + } + xfer += iprot->readListEnd(); + } + this->__isset.names = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->exprs.clear(); + uint32_t _size742; + ::apache::thrift::protocol::TType _etype745; + xfer += iprot->readListBegin(_etype745, _size742); + this->exprs.resize(_size742); + uint32_t _i746; + for (_i746 = 0; _i746 < _size742; ++_i746) + { + xfer += this->exprs[_i746].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.exprs = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t RequestPartsSpec::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("RequestPartsSpec"); + + if (this->__isset.names) { + xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->names.size())); + std::vector ::const_iterator _iter747; + for (_iter747 = this->names.begin(); _iter747 != this->names.end(); ++_iter747) + { + xfer += oprot->writeString((*_iter747)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.exprs) { + xfer += oprot->writeFieldBegin("exprs", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->exprs.size())); + std::vector ::const_iterator _iter748; + for (_iter748 = this->exprs.begin(); _iter748 != this->exprs.end(); ++_iter748) + { + xfer += (*_iter748).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(RequestPartsSpec &a, RequestPartsSpec &b) noexcept { + using ::std::swap; + swap(a.names, b.names); + swap(a.exprs, b.exprs); + swap(a.__isset, b.__isset); +} + +bool RequestPartsSpec::operator==(const RequestPartsSpec & rhs) const +{ + if (__isset.names != rhs.__isset.names) + return false; + else if (__isset.names && !(names == rhs.names)) + return false; + if (__isset.exprs != rhs.__isset.exprs) + return false; + else if (__isset.exprs && !(exprs == rhs.exprs)) + return false; + return true; +} + +RequestPartsSpec::RequestPartsSpec(const RequestPartsSpec& other749) { + names = other749.names; + exprs = other749.exprs; + __isset = other749.__isset; +} +RequestPartsSpec& RequestPartsSpec::operator=(const RequestPartsSpec& other750) { + names = other750.names; + exprs = other750.exprs; + __isset = other750.__isset; + return *this; +} +void RequestPartsSpec::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "RequestPartsSpec("; + out << "names="; (__isset.names ? (out << to_string(names)) : (out << "")); + out << ", " << "exprs="; (__isset.exprs ? (out << to_string(exprs)) : (out << "")); + out << ")"; +} + + +DropPartitionsRequest::~DropPartitionsRequest() noexcept { +} + +DropPartitionsRequest::DropPartitionsRequest() noexcept + : dbName(), + tblName(), + deleteData(0), + ifExists(true), + ignoreProtection(0), + needResult(true), + catName(), + skipColumnSchemaForPartition(0) { +} + +void DropPartitionsRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void DropPartitionsRequest::__set_tblName(const std::string& val) { + this->tblName = val; +} + +void DropPartitionsRequest::__set_parts(const RequestPartsSpec& val) { + this->parts = val; +} + +void DropPartitionsRequest::__set_deleteData(const bool val) { + this->deleteData = val; +__isset.deleteData = true; +} + +void DropPartitionsRequest::__set_ifExists(const bool val) { + this->ifExists = val; +__isset.ifExists = true; +} + +void DropPartitionsRequest::__set_ignoreProtection(const bool val) { + this->ignoreProtection = val; +__isset.ignoreProtection = true; +} + +void DropPartitionsRequest::__set_environmentContext(const EnvironmentContext& val) { + this->environmentContext = val; +__isset.environmentContext = true; +} + +void DropPartitionsRequest::__set_needResult(const bool val) { + this->needResult = val; +__isset.needResult = true; +} + +void DropPartitionsRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void DropPartitionsRequest::__set_skipColumnSchemaForPartition(const bool val) { + this->skipColumnSchemaForPartition = val; +__isset.skipColumnSchemaForPartition = true; +} +std::ostream& operator<<(std::ostream& out, const DropPartitionsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t DropPartitionsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tblName = false; + bool isset_parts = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tblName); + isset_tblName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->parts.read(iprot); + isset_parts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->deleteData); + this->__isset.deleteData = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->ifExists); + this->__isset.ifExists = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->ignoreProtection); + this->__isset.ignoreProtection = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->environmentContext.read(iprot); + this->__isset.environmentContext = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->needResult); + this->__isset.needResult = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->skipColumnSchemaForPartition); + this->__isset.skipColumnSchemaForPartition = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tblName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_parts) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t DropPartitionsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("DropPartitionsRequest"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tblName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("parts", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->parts.write(oprot); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.deleteData) { + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool(this->deleteData); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ifExists) { + xfer += oprot->writeFieldBegin("ifExists", ::apache::thrift::protocol::T_BOOL, 5); + xfer += oprot->writeBool(this->ifExists); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ignoreProtection) { + xfer += oprot->writeFieldBegin("ignoreProtection", ::apache::thrift::protocol::T_BOOL, 6); + xfer += oprot->writeBool(this->ignoreProtection); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.environmentContext) { + xfer += oprot->writeFieldBegin("environmentContext", ::apache::thrift::protocol::T_STRUCT, 7); + xfer += this->environmentContext.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.needResult) { + xfer += oprot->writeFieldBegin("needResult", ::apache::thrift::protocol::T_BOOL, 8); + xfer += oprot->writeBool(this->needResult); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 9); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.skipColumnSchemaForPartition) { + xfer += oprot->writeFieldBegin("skipColumnSchemaForPartition", ::apache::thrift::protocol::T_BOOL, 10); + xfer += oprot->writeBool(this->skipColumnSchemaForPartition); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(DropPartitionsRequest &a, DropPartitionsRequest &b) noexcept { + using ::std::swap; + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); + swap(a.parts, b.parts); + swap(a.deleteData, b.deleteData); + swap(a.ifExists, b.ifExists); + swap(a.ignoreProtection, b.ignoreProtection); + swap(a.environmentContext, b.environmentContext); + swap(a.needResult, b.needResult); + swap(a.catName, b.catName); + swap(a.skipColumnSchemaForPartition, b.skipColumnSchemaForPartition); + swap(a.__isset, b.__isset); +} + +bool DropPartitionsRequest::operator==(const DropPartitionsRequest & rhs) const +{ + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + if (!(parts == rhs.parts)) + return false; + if (__isset.deleteData != rhs.__isset.deleteData) + return false; + else if (__isset.deleteData && !(deleteData == rhs.deleteData)) + return false; + if (__isset.ifExists != rhs.__isset.ifExists) + return false; + else if (__isset.ifExists && !(ifExists == rhs.ifExists)) + return false; + if (__isset.ignoreProtection != rhs.__isset.ignoreProtection) + return false; + else if (__isset.ignoreProtection && !(ignoreProtection == rhs.ignoreProtection)) + return false; + if (__isset.environmentContext != rhs.__isset.environmentContext) + return false; + else if (__isset.environmentContext && !(environmentContext == rhs.environmentContext)) + return false; + if (__isset.needResult != rhs.__isset.needResult) + return false; + else if (__isset.needResult && !(needResult == rhs.needResult)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (__isset.skipColumnSchemaForPartition != rhs.__isset.skipColumnSchemaForPartition) + return false; + else if (__isset.skipColumnSchemaForPartition && !(skipColumnSchemaForPartition == rhs.skipColumnSchemaForPartition)) + return false; + return true; +} + +DropPartitionsRequest::DropPartitionsRequest(const DropPartitionsRequest& other751) { + dbName = other751.dbName; + tblName = other751.tblName; + parts = other751.parts; + deleteData = other751.deleteData; + ifExists = other751.ifExists; + ignoreProtection = other751.ignoreProtection; + environmentContext = other751.environmentContext; + needResult = other751.needResult; + catName = other751.catName; + skipColumnSchemaForPartition = other751.skipColumnSchemaForPartition; + __isset = other751.__isset; +} +DropPartitionsRequest& DropPartitionsRequest::operator=(const DropPartitionsRequest& other752) { + dbName = other752.dbName; + tblName = other752.tblName; + parts = other752.parts; + deleteData = other752.deleteData; + ifExists = other752.ifExists; + ignoreProtection = other752.ignoreProtection; + environmentContext = other752.environmentContext; + needResult = other752.needResult; + catName = other752.catName; + skipColumnSchemaForPartition = other752.skipColumnSchemaForPartition; + __isset = other752.__isset; + return *this; +} +void DropPartitionsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "DropPartitionsRequest("; + out << "dbName=" << to_string(dbName); + out << ", " << "tblName=" << to_string(tblName); + out << ", " << "parts=" << to_string(parts); + out << ", " << "deleteData="; (__isset.deleteData ? (out << to_string(deleteData)) : (out << "")); + out << ", " << "ifExists="; (__isset.ifExists ? (out << to_string(ifExists)) : (out << "")); + out << ", " << "ignoreProtection="; (__isset.ignoreProtection ? (out << to_string(ignoreProtection)) : (out << "")); + out << ", " << "environmentContext="; (__isset.environmentContext ? (out << to_string(environmentContext)) : (out << "")); + out << ", " << "needResult="; (__isset.needResult ? (out << to_string(needResult)) : (out << "")); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "skipColumnSchemaForPartition="; (__isset.skipColumnSchemaForPartition ? (out << to_string(skipColumnSchemaForPartition)) : (out << "")); + out << ")"; +} + + +DropPartitionRequest::~DropPartitionRequest() noexcept { +} + +DropPartitionRequest::DropPartitionRequest() noexcept + : catName(), + dbName(), + tblName(), + partName(), + deleteData(0) { +} + +void DropPartitionRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void DropPartitionRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void DropPartitionRequest::__set_tblName(const std::string& val) { + this->tblName = val; +} + +void DropPartitionRequest::__set_partName(const std::string& val) { + this->partName = val; +__isset.partName = true; +} + +void DropPartitionRequest::__set_partVals(const std::vector & val) { + this->partVals = val; +__isset.partVals = true; +} + +void DropPartitionRequest::__set_deleteData(const bool val) { + this->deleteData = val; +__isset.deleteData = true; +} + +void DropPartitionRequest::__set_environmentContext(const EnvironmentContext& val) { + this->environmentContext = val; +__isset.environmentContext = true; +} +std::ostream& operator<<(std::ostream& out, const DropPartitionRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t DropPartitionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tblName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tblName); + isset_tblName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->partName); + this->__isset.partName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partVals.clear(); + uint32_t _size753; + ::apache::thrift::protocol::TType _etype756; + xfer += iprot->readListBegin(_etype756, _size753); + this->partVals.resize(_size753); + uint32_t _i757; + for (_i757 = 0; _i757 < _size753; ++_i757) + { + xfer += iprot->readString(this->partVals[_i757]); + } + xfer += iprot->readListEnd(); + } + this->__isset.partVals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->deleteData); + this->__isset.deleteData = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->environmentContext.read(iprot); + this->__isset.environmentContext = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tblName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t DropPartitionRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("DropPartitionRequest"); + + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tblName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.partName) { + xfer += oprot->writeFieldBegin("partName", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->partName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.partVals) { + xfer += oprot->writeFieldBegin("partVals", ::apache::thrift::protocol::T_LIST, 5); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partVals.size())); + std::vector ::const_iterator _iter758; + for (_iter758 = this->partVals.begin(); _iter758 != this->partVals.end(); ++_iter758) + { + xfer += oprot->writeString((*_iter758)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.deleteData) { + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 6); + xfer += oprot->writeBool(this->deleteData); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.environmentContext) { + xfer += oprot->writeFieldBegin("environmentContext", ::apache::thrift::protocol::T_STRUCT, 7); + xfer += this->environmentContext.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(DropPartitionRequest &a, DropPartitionRequest &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); + swap(a.partName, b.partName); + swap(a.partVals, b.partVals); + swap(a.deleteData, b.deleteData); + swap(a.environmentContext, b.environmentContext); + swap(a.__isset, b.__isset); +} + +bool DropPartitionRequest::operator==(const DropPartitionRequest & rhs) const +{ + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + if (__isset.partName != rhs.__isset.partName) + return false; + else if (__isset.partName && !(partName == rhs.partName)) + return false; + if (__isset.partVals != rhs.__isset.partVals) + return false; + else if (__isset.partVals && !(partVals == rhs.partVals)) + return false; + if (__isset.deleteData != rhs.__isset.deleteData) + return false; + else if (__isset.deleteData && !(deleteData == rhs.deleteData)) + return false; + if (__isset.environmentContext != rhs.__isset.environmentContext) + return false; + else if (__isset.environmentContext && !(environmentContext == rhs.environmentContext)) + return false; + return true; +} + +DropPartitionRequest::DropPartitionRequest(const DropPartitionRequest& other759) { + catName = other759.catName; + dbName = other759.dbName; + tblName = other759.tblName; + partName = other759.partName; + partVals = other759.partVals; + deleteData = other759.deleteData; + environmentContext = other759.environmentContext; + __isset = other759.__isset; +} +DropPartitionRequest& DropPartitionRequest::operator=(const DropPartitionRequest& other760) { + catName = other760.catName; + dbName = other760.dbName; + tblName = other760.tblName; + partName = other760.partName; + partVals = other760.partVals; + deleteData = other760.deleteData; + environmentContext = other760.environmentContext; + __isset = other760.__isset; + return *this; +} +void DropPartitionRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "DropPartitionRequest("; + out << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "tblName=" << to_string(tblName); + out << ", " << "partName="; (__isset.partName ? (out << to_string(partName)) : (out << "")); + out << ", " << "partVals="; (__isset.partVals ? (out << to_string(partVals)) : (out << "")); + out << ", " << "deleteData="; (__isset.deleteData ? (out << to_string(deleteData)) : (out << "")); + out << ", " << "environmentContext="; (__isset.environmentContext ? (out << to_string(environmentContext)) : (out << "")); + out << ")"; +} + + +PartitionValuesRequest::~PartitionValuesRequest() noexcept { +} + +PartitionValuesRequest::PartitionValuesRequest() noexcept + : dbName(), + tblName(), + applyDistinct(true), + filter(), + ascending(true), + maxParts(-1LL), + catName(), + validWriteIdList() { +} + +void PartitionValuesRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void PartitionValuesRequest::__set_tblName(const std::string& val) { + this->tblName = val; +} + +void PartitionValuesRequest::__set_partitionKeys(const std::vector & val) { + this->partitionKeys = val; +} + +void PartitionValuesRequest::__set_applyDistinct(const bool val) { + this->applyDistinct = val; +__isset.applyDistinct = true; +} + +void PartitionValuesRequest::__set_filter(const std::string& val) { + this->filter = val; +__isset.filter = true; +} + +void PartitionValuesRequest::__set_partitionOrder(const std::vector & val) { + this->partitionOrder = val; +__isset.partitionOrder = true; +} + +void PartitionValuesRequest::__set_ascending(const bool val) { + this->ascending = val; +__isset.ascending = true; +} + +void PartitionValuesRequest::__set_maxParts(const int64_t val) { + this->maxParts = val; +__isset.maxParts = true; +} + +void PartitionValuesRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void PartitionValuesRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} +std::ostream& operator<<(std::ostream& out, const PartitionValuesRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PartitionValuesRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tblName = false; + bool isset_partitionKeys = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tblName); + isset_tblName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitionKeys.clear(); + uint32_t _size761; + ::apache::thrift::protocol::TType _etype764; + xfer += iprot->readListBegin(_etype764, _size761); + this->partitionKeys.resize(_size761); + uint32_t _i765; + for (_i765 = 0; _i765 < _size761; ++_i765) + { + xfer += this->partitionKeys[_i765].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_partitionKeys = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->applyDistinct); + this->__isset.applyDistinct = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->filter); + this->__isset.filter = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitionOrder.clear(); + uint32_t _size766; + ::apache::thrift::protocol::TType _etype769; + xfer += iprot->readListBegin(_etype769, _size766); + this->partitionOrder.resize(_size766); + uint32_t _i770; + for (_i770 = 0; _i770 < _size766; ++_i770) + { + xfer += this->partitionOrder[_i770].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.partitionOrder = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->ascending); + this->__isset.ascending = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->maxParts); + this->__isset.maxParts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tblName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_partitionKeys) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t PartitionValuesRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PartitionValuesRequest"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tblName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("partitionKeys", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionKeys.size())); + std::vector ::const_iterator _iter771; + for (_iter771 = this->partitionKeys.begin(); _iter771 != this->partitionKeys.end(); ++_iter771) + { + xfer += (*_iter771).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.applyDistinct) { + xfer += oprot->writeFieldBegin("applyDistinct", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool(this->applyDistinct); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.filter) { + xfer += oprot->writeFieldBegin("filter", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->filter); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.partitionOrder) { + xfer += oprot->writeFieldBegin("partitionOrder", ::apache::thrift::protocol::T_LIST, 6); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionOrder.size())); + std::vector ::const_iterator _iter772; + for (_iter772 = this->partitionOrder.begin(); _iter772 != this->partitionOrder.end(); ++_iter772) + { + xfer += (*_iter772).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ascending) { + xfer += oprot->writeFieldBegin("ascending", ::apache::thrift::protocol::T_BOOL, 7); + xfer += oprot->writeBool(this->ascending); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.maxParts) { + xfer += oprot->writeFieldBegin("maxParts", ::apache::thrift::protocol::T_I64, 8); + xfer += oprot->writeI64(this->maxParts); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 9); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 10); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PartitionValuesRequest &a, PartitionValuesRequest &b) noexcept { + using ::std::swap; + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); + swap(a.partitionKeys, b.partitionKeys); + swap(a.applyDistinct, b.applyDistinct); + swap(a.filter, b.filter); + swap(a.partitionOrder, b.partitionOrder); + swap(a.ascending, b.ascending); + swap(a.maxParts, b.maxParts); + swap(a.catName, b.catName); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.__isset, b.__isset); +} + +bool PartitionValuesRequest::operator==(const PartitionValuesRequest & rhs) const +{ + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + if (!(partitionKeys == rhs.partitionKeys)) + return false; + if (__isset.applyDistinct != rhs.__isset.applyDistinct) + return false; + else if (__isset.applyDistinct && !(applyDistinct == rhs.applyDistinct)) + return false; + if (__isset.filter != rhs.__isset.filter) + return false; + else if (__isset.filter && !(filter == rhs.filter)) + return false; + if (__isset.partitionOrder != rhs.__isset.partitionOrder) + return false; + else if (__isset.partitionOrder && !(partitionOrder == rhs.partitionOrder)) + return false; + if (__isset.ascending != rhs.__isset.ascending) + return false; + else if (__isset.ascending && !(ascending == rhs.ascending)) + return false; + if (__isset.maxParts != rhs.__isset.maxParts) + return false; + else if (__isset.maxParts && !(maxParts == rhs.maxParts)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + return true; +} + +PartitionValuesRequest::PartitionValuesRequest(const PartitionValuesRequest& other773) { + dbName = other773.dbName; + tblName = other773.tblName; + partitionKeys = other773.partitionKeys; + applyDistinct = other773.applyDistinct; + filter = other773.filter; + partitionOrder = other773.partitionOrder; + ascending = other773.ascending; + maxParts = other773.maxParts; + catName = other773.catName; + validWriteIdList = other773.validWriteIdList; + __isset = other773.__isset; +} +PartitionValuesRequest& PartitionValuesRequest::operator=(const PartitionValuesRequest& other774) { + dbName = other774.dbName; + tblName = other774.tblName; + partitionKeys = other774.partitionKeys; + applyDistinct = other774.applyDistinct; + filter = other774.filter; + partitionOrder = other774.partitionOrder; + ascending = other774.ascending; + maxParts = other774.maxParts; + catName = other774.catName; + validWriteIdList = other774.validWriteIdList; + __isset = other774.__isset; + return *this; +} +void PartitionValuesRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PartitionValuesRequest("; + out << "dbName=" << to_string(dbName); + out << ", " << "tblName=" << to_string(tblName); + out << ", " << "partitionKeys=" << to_string(partitionKeys); + out << ", " << "applyDistinct="; (__isset.applyDistinct ? (out << to_string(applyDistinct)) : (out << "")); + out << ", " << "filter="; (__isset.filter ? (out << to_string(filter)) : (out << "")); + out << ", " << "partitionOrder="; (__isset.partitionOrder ? (out << to_string(partitionOrder)) : (out << "")); + out << ", " << "ascending="; (__isset.ascending ? (out << to_string(ascending)) : (out << "")); + out << ", " << "maxParts="; (__isset.maxParts ? (out << to_string(maxParts)) : (out << "")); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ")"; +} + + +PartitionValuesRow::~PartitionValuesRow() noexcept { +} + +PartitionValuesRow::PartitionValuesRow() noexcept { +} + +void PartitionValuesRow::__set_row(const std::vector & val) { + this->row = val; +} +std::ostream& operator<<(std::ostream& out, const PartitionValuesRow& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PartitionValuesRow::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_row = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->row.clear(); + uint32_t _size775; + ::apache::thrift::protocol::TType _etype778; + xfer += iprot->readListBegin(_etype778, _size775); + this->row.resize(_size775); + uint32_t _i779; + for (_i779 = 0; _i779 < _size775; ++_i779) + { + xfer += iprot->readString(this->row[_i779]); + } + xfer += iprot->readListEnd(); + } + isset_row = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_row) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t PartitionValuesRow::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PartitionValuesRow"); + + xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->row.size())); + std::vector ::const_iterator _iter780; + for (_iter780 = this->row.begin(); _iter780 != this->row.end(); ++_iter780) + { + xfer += oprot->writeString((*_iter780)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PartitionValuesRow &a, PartitionValuesRow &b) noexcept { + using ::std::swap; + swap(a.row, b.row); +} + +bool PartitionValuesRow::operator==(const PartitionValuesRow & rhs) const +{ + if (!(row == rhs.row)) + return false; + return true; +} + +PartitionValuesRow::PartitionValuesRow(const PartitionValuesRow& other781) { + row = other781.row; +} +PartitionValuesRow& PartitionValuesRow::operator=(const PartitionValuesRow& other782) { + row = other782.row; + return *this; +} +void PartitionValuesRow::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PartitionValuesRow("; + out << "row=" << to_string(row); + out << ")"; +} + + +PartitionValuesResponse::~PartitionValuesResponse() noexcept { +} + +PartitionValuesResponse::PartitionValuesResponse() noexcept { +} + +void PartitionValuesResponse::__set_partitionValues(const std::vector & val) { + this->partitionValues = val; +} +std::ostream& operator<<(std::ostream& out, const PartitionValuesResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PartitionValuesResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_partitionValues = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitionValues.clear(); + uint32_t _size783; + ::apache::thrift::protocol::TType _etype786; + xfer += iprot->readListBegin(_etype786, _size783); + this->partitionValues.resize(_size783); + uint32_t _i787; + for (_i787 = 0; _i787 < _size783; ++_i787) + { + xfer += this->partitionValues[_i787].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_partitionValues = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_partitionValues) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t PartitionValuesResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PartitionValuesResponse"); + + xfer += oprot->writeFieldBegin("partitionValues", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionValues.size())); + std::vector ::const_iterator _iter788; + for (_iter788 = this->partitionValues.begin(); _iter788 != this->partitionValues.end(); ++_iter788) + { + xfer += (*_iter788).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PartitionValuesResponse &a, PartitionValuesResponse &b) noexcept { + using ::std::swap; + swap(a.partitionValues, b.partitionValues); +} + +bool PartitionValuesResponse::operator==(const PartitionValuesResponse & rhs) const +{ + if (!(partitionValues == rhs.partitionValues)) + return false; + return true; +} + +PartitionValuesResponse::PartitionValuesResponse(const PartitionValuesResponse& other789) { + partitionValues = other789.partitionValues; +} +PartitionValuesResponse& PartitionValuesResponse::operator=(const PartitionValuesResponse& other790) { + partitionValues = other790.partitionValues; + return *this; +} +void PartitionValuesResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PartitionValuesResponse("; + out << "partitionValues=" << to_string(partitionValues); + out << ")"; +} + + +GetPartitionsByNamesRequest::~GetPartitionsByNamesRequest() noexcept { +} + +GetPartitionsByNamesRequest::GetPartitionsByNamesRequest() : db_name(), + tbl_name(), + get_col_stats(0), + processorIdentifier(), + engine("hive"), + validWriteIdList(), + getFileMetadata(0), + id(-1LL), + skipColumnSchemaForPartition(0), + includeParamKeyPattern(), + excludeParamKeyPattern() { +} + +void GetPartitionsByNamesRequest::__set_db_name(const std::string& val) { + this->db_name = val; +} + +void GetPartitionsByNamesRequest::__set_tbl_name(const std::string& val) { + this->tbl_name = val; +} + +void GetPartitionsByNamesRequest::__set_names(const std::vector & val) { + this->names = val; +__isset.names = true; +} + +void GetPartitionsByNamesRequest::__set_get_col_stats(const bool val) { + this->get_col_stats = val; +__isset.get_col_stats = true; +} + +void GetPartitionsByNamesRequest::__set_processorCapabilities(const std::vector & val) { + this->processorCapabilities = val; +__isset.processorCapabilities = true; +} + +void GetPartitionsByNamesRequest::__set_processorIdentifier(const std::string& val) { + this->processorIdentifier = val; +__isset.processorIdentifier = true; +} + +void GetPartitionsByNamesRequest::__set_engine(const std::string& val) { + this->engine = val; +__isset.engine = true; +} + +void GetPartitionsByNamesRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void GetPartitionsByNamesRequest::__set_getFileMetadata(const bool val) { + this->getFileMetadata = val; +__isset.getFileMetadata = true; +} + +void GetPartitionsByNamesRequest::__set_id(const int64_t val) { + this->id = val; +__isset.id = true; +} + +void GetPartitionsByNamesRequest::__set_skipColumnSchemaForPartition(const bool val) { + this->skipColumnSchemaForPartition = val; +__isset.skipColumnSchemaForPartition = true; +} + +void GetPartitionsByNamesRequest::__set_includeParamKeyPattern(const std::string& val) { + this->includeParamKeyPattern = val; +__isset.includeParamKeyPattern = true; +} + +void GetPartitionsByNamesRequest::__set_excludeParamKeyPattern(const std::string& val) { + this->excludeParamKeyPattern = val; +__isset.excludeParamKeyPattern = true; +} +std::ostream& operator<<(std::ostream& out, const GetPartitionsByNamesRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetPartitionsByNamesRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_db_name = false; + bool isset_tbl_name = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + isset_db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + isset_tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->names.clear(); + uint32_t _size791; + ::apache::thrift::protocol::TType _etype794; + xfer += iprot->readListBegin(_etype794, _size791); + this->names.resize(_size791); + uint32_t _i795; + for (_i795 = 0; _i795 < _size791; ++_i795) + { + xfer += iprot->readString(this->names[_i795]); + } + xfer += iprot->readListEnd(); + } + this->__isset.names = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->get_col_stats); + this->__isset.get_col_stats = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->processorCapabilities.clear(); + uint32_t _size796; + ::apache::thrift::protocol::TType _etype799; + xfer += iprot->readListBegin(_etype799, _size796); + this->processorCapabilities.resize(_size796); + uint32_t _i800; + for (_i800 = 0; _i800 < _size796; ++_i800) + { + xfer += iprot->readString(this->processorCapabilities[_i800]); + } + xfer += iprot->readListEnd(); + } + this->__isset.processorCapabilities = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->processorIdentifier); + this->__isset.processorIdentifier = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->engine); + this->__isset.engine = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->getFileMetadata); + this->__isset.getFileMetadata = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->id); + this->__isset.id = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 11: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->skipColumnSchemaForPartition); + this->__isset.skipColumnSchemaForPartition = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 12: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->includeParamKeyPattern); + this->__isset.includeParamKeyPattern = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 13: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->excludeParamKeyPattern); + this->__isset.excludeParamKeyPattern = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_db_name) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tbl_name) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetPartitionsByNamesRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetPartitionsByNamesRequest"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.names) { + xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->names.size())); + std::vector ::const_iterator _iter801; + for (_iter801 = this->names.begin(); _iter801 != this->names.end(); ++_iter801) + { + xfer += oprot->writeString((*_iter801)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.get_col_stats) { + xfer += oprot->writeFieldBegin("get_col_stats", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool(this->get_col_stats); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.processorCapabilities) { + xfer += oprot->writeFieldBegin("processorCapabilities", ::apache::thrift::protocol::T_LIST, 5); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->processorCapabilities.size())); + std::vector ::const_iterator _iter802; + for (_iter802 = this->processorCapabilities.begin(); _iter802 != this->processorCapabilities.end(); ++_iter802) + { + xfer += oprot->writeString((*_iter802)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.processorIdentifier) { + xfer += oprot->writeFieldBegin("processorIdentifier", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->processorIdentifier); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.engine) { + xfer += oprot->writeFieldBegin("engine", ::apache::thrift::protocol::T_STRING, 7); + xfer += oprot->writeString(this->engine); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 8); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.getFileMetadata) { + xfer += oprot->writeFieldBegin("getFileMetadata", ::apache::thrift::protocol::T_BOOL, 9); + xfer += oprot->writeBool(this->getFileMetadata); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.id) { + xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I64, 10); + xfer += oprot->writeI64(this->id); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.skipColumnSchemaForPartition) { + xfer += oprot->writeFieldBegin("skipColumnSchemaForPartition", ::apache::thrift::protocol::T_BOOL, 11); + xfer += oprot->writeBool(this->skipColumnSchemaForPartition); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.includeParamKeyPattern) { + xfer += oprot->writeFieldBegin("includeParamKeyPattern", ::apache::thrift::protocol::T_STRING, 12); + xfer += oprot->writeString(this->includeParamKeyPattern); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.excludeParamKeyPattern) { + xfer += oprot->writeFieldBegin("excludeParamKeyPattern", ::apache::thrift::protocol::T_STRING, 13); + xfer += oprot->writeString(this->excludeParamKeyPattern); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetPartitionsByNamesRequest &a, GetPartitionsByNamesRequest &b) noexcept { + using ::std::swap; + swap(a.db_name, b.db_name); + swap(a.tbl_name, b.tbl_name); + swap(a.names, b.names); + swap(a.get_col_stats, b.get_col_stats); + swap(a.processorCapabilities, b.processorCapabilities); + swap(a.processorIdentifier, b.processorIdentifier); + swap(a.engine, b.engine); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.getFileMetadata, b.getFileMetadata); + swap(a.id, b.id); + swap(a.skipColumnSchemaForPartition, b.skipColumnSchemaForPartition); + swap(a.includeParamKeyPattern, b.includeParamKeyPattern); + swap(a.excludeParamKeyPattern, b.excludeParamKeyPattern); + swap(a.__isset, b.__isset); +} + +bool GetPartitionsByNamesRequest::operator==(const GetPartitionsByNamesRequest & rhs) const +{ + if (!(db_name == rhs.db_name)) + return false; + if (!(tbl_name == rhs.tbl_name)) + return false; + if (__isset.names != rhs.__isset.names) + return false; + else if (__isset.names && !(names == rhs.names)) + return false; + if (__isset.get_col_stats != rhs.__isset.get_col_stats) + return false; + else if (__isset.get_col_stats && !(get_col_stats == rhs.get_col_stats)) + return false; + if (__isset.processorCapabilities != rhs.__isset.processorCapabilities) + return false; + else if (__isset.processorCapabilities && !(processorCapabilities == rhs.processorCapabilities)) + return false; + if (__isset.processorIdentifier != rhs.__isset.processorIdentifier) + return false; + else if (__isset.processorIdentifier && !(processorIdentifier == rhs.processorIdentifier)) + return false; + if (__isset.engine != rhs.__isset.engine) + return false; + else if (__isset.engine && !(engine == rhs.engine)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.getFileMetadata != rhs.__isset.getFileMetadata) + return false; + else if (__isset.getFileMetadata && !(getFileMetadata == rhs.getFileMetadata)) + return false; + if (__isset.id != rhs.__isset.id) + return false; + else if (__isset.id && !(id == rhs.id)) + return false; + if (__isset.skipColumnSchemaForPartition != rhs.__isset.skipColumnSchemaForPartition) + return false; + else if (__isset.skipColumnSchemaForPartition && !(skipColumnSchemaForPartition == rhs.skipColumnSchemaForPartition)) + return false; + if (__isset.includeParamKeyPattern != rhs.__isset.includeParamKeyPattern) + return false; + else if (__isset.includeParamKeyPattern && !(includeParamKeyPattern == rhs.includeParamKeyPattern)) + return false; + if (__isset.excludeParamKeyPattern != rhs.__isset.excludeParamKeyPattern) + return false; + else if (__isset.excludeParamKeyPattern && !(excludeParamKeyPattern == rhs.excludeParamKeyPattern)) + return false; + return true; +} + +GetPartitionsByNamesRequest::GetPartitionsByNamesRequest(const GetPartitionsByNamesRequest& other803) { + db_name = other803.db_name; + tbl_name = other803.tbl_name; + names = other803.names; + get_col_stats = other803.get_col_stats; + processorCapabilities = other803.processorCapabilities; + processorIdentifier = other803.processorIdentifier; + engine = other803.engine; + validWriteIdList = other803.validWriteIdList; + getFileMetadata = other803.getFileMetadata; + id = other803.id; + skipColumnSchemaForPartition = other803.skipColumnSchemaForPartition; + includeParamKeyPattern = other803.includeParamKeyPattern; + excludeParamKeyPattern = other803.excludeParamKeyPattern; + __isset = other803.__isset; +} +GetPartitionsByNamesRequest& GetPartitionsByNamesRequest::operator=(const GetPartitionsByNamesRequest& other804) { + db_name = other804.db_name; + tbl_name = other804.tbl_name; + names = other804.names; + get_col_stats = other804.get_col_stats; + processorCapabilities = other804.processorCapabilities; + processorIdentifier = other804.processorIdentifier; + engine = other804.engine; + validWriteIdList = other804.validWriteIdList; + getFileMetadata = other804.getFileMetadata; + id = other804.id; + skipColumnSchemaForPartition = other804.skipColumnSchemaForPartition; + includeParamKeyPattern = other804.includeParamKeyPattern; + excludeParamKeyPattern = other804.excludeParamKeyPattern; + __isset = other804.__isset; + return *this; +} +void GetPartitionsByNamesRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetPartitionsByNamesRequest("; + out << "db_name=" << to_string(db_name); + out << ", " << "tbl_name=" << to_string(tbl_name); + out << ", " << "names="; (__isset.names ? (out << to_string(names)) : (out << "")); + out << ", " << "get_col_stats="; (__isset.get_col_stats ? (out << to_string(get_col_stats)) : (out << "")); + out << ", " << "processorCapabilities="; (__isset.processorCapabilities ? (out << to_string(processorCapabilities)) : (out << "")); + out << ", " << "processorIdentifier="; (__isset.processorIdentifier ? (out << to_string(processorIdentifier)) : (out << "")); + out << ", " << "engine="; (__isset.engine ? (out << to_string(engine)) : (out << "")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "getFileMetadata="; (__isset.getFileMetadata ? (out << to_string(getFileMetadata)) : (out << "")); + out << ", " << "id="; (__isset.id ? (out << to_string(id)) : (out << "")); + out << ", " << "skipColumnSchemaForPartition="; (__isset.skipColumnSchemaForPartition ? (out << to_string(skipColumnSchemaForPartition)) : (out << "")); + out << ", " << "includeParamKeyPattern="; (__isset.includeParamKeyPattern ? (out << to_string(includeParamKeyPattern)) : (out << "")); + out << ", " << "excludeParamKeyPattern="; (__isset.excludeParamKeyPattern ? (out << to_string(excludeParamKeyPattern)) : (out << "")); + out << ")"; +} + + +GetPartitionsByNamesResult::~GetPartitionsByNamesResult() noexcept { +} + +GetPartitionsByNamesResult::GetPartitionsByNamesResult() noexcept { +} + +void GetPartitionsByNamesResult::__set_partitions(const std::vector & val) { + this->partitions = val; +} + +void GetPartitionsByNamesResult::__set_dictionary(const ObjectDictionary& val) { + this->dictionary = val; +__isset.dictionary = true; +} +std::ostream& operator<<(std::ostream& out, const GetPartitionsByNamesResult& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetPartitionsByNamesResult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_partitions = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitions.clear(); + uint32_t _size805; + ::apache::thrift::protocol::TType _etype808; + xfer += iprot->readListBegin(_etype808, _size805); + this->partitions.resize(_size805); + uint32_t _i809; + for (_i809 = 0; _i809 < _size805; ++_i809) + { + xfer += this->partitions[_i809].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_partitions = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->dictionary.read(iprot); + this->__isset.dictionary = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_partitions) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetPartitionsByNamesResult::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetPartitionsByNamesResult"); + + xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); + std::vector ::const_iterator _iter810; + for (_iter810 = this->partitions.begin(); _iter810 != this->partitions.end(); ++_iter810) + { + xfer += (*_iter810).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.dictionary) { + xfer += oprot->writeFieldBegin("dictionary", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->dictionary.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetPartitionsByNamesResult &a, GetPartitionsByNamesResult &b) noexcept { + using ::std::swap; + swap(a.partitions, b.partitions); + swap(a.dictionary, b.dictionary); + swap(a.__isset, b.__isset); +} + +bool GetPartitionsByNamesResult::operator==(const GetPartitionsByNamesResult & rhs) const +{ + if (!(partitions == rhs.partitions)) + return false; + if (__isset.dictionary != rhs.__isset.dictionary) + return false; + else if (__isset.dictionary && !(dictionary == rhs.dictionary)) + return false; + return true; +} + +GetPartitionsByNamesResult::GetPartitionsByNamesResult(const GetPartitionsByNamesResult& other811) { + partitions = other811.partitions; + dictionary = other811.dictionary; + __isset = other811.__isset; +} +GetPartitionsByNamesResult& GetPartitionsByNamesResult::operator=(const GetPartitionsByNamesResult& other812) { + partitions = other812.partitions; + dictionary = other812.dictionary; + __isset = other812.__isset; + return *this; +} +void GetPartitionsByNamesResult::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetPartitionsByNamesResult("; + out << "partitions=" << to_string(partitions); + out << ", " << "dictionary="; (__isset.dictionary ? (out << to_string(dictionary)) : (out << "")); + out << ")"; +} + + +DataConnector::~DataConnector() noexcept { +} + +DataConnector::DataConnector() noexcept + : name(), + type(), + url(), + description(), + ownerName(), + ownerType(static_cast(0)), + createTime(0) { +} + +void DataConnector::__set_name(const std::string& val) { + this->name = val; +} + +void DataConnector::__set_type(const std::string& val) { + this->type = val; +} + +void DataConnector::__set_url(const std::string& val) { + this->url = val; +} + +void DataConnector::__set_description(const std::string& val) { + this->description = val; +__isset.description = true; +} + +void DataConnector::__set_parameters(const std::map & val) { + this->parameters = val; +__isset.parameters = true; +} + +void DataConnector::__set_ownerName(const std::string& val) { + this->ownerName = val; +__isset.ownerName = true; +} + +void DataConnector::__set_ownerType(const PrincipalType::type val) { + this->ownerType = val; +__isset.ownerType = true; +} + +void DataConnector::__set_createTime(const int32_t val) { + this->createTime = val; +__isset.createTime = true; +} +std::ostream& operator<<(std::ostream& out, const DataConnector& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t DataConnector::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->type); + this->__isset.type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->url); + this->__isset.url = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->description); + this->__isset.description = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->parameters.clear(); + uint32_t _size813; + ::apache::thrift::protocol::TType _ktype814; + ::apache::thrift::protocol::TType _vtype815; + xfer += iprot->readMapBegin(_ktype814, _vtype815, _size813); + uint32_t _i817; + for (_i817 = 0; _i817 < _size813; ++_i817) + { + std::string _key818; + xfer += iprot->readString(_key818); + std::string& _val819 = this->parameters[_key818]; + xfer += iprot->readString(_val819); + } + xfer += iprot->readMapEnd(); + } + this->__isset.parameters = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ownerName); + this->__isset.ownerName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast820; + xfer += iprot->readI32(ecast820); + this->ownerType = static_cast(ecast820); + this->__isset.ownerType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->createTime); + this->__isset.createTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t DataConnector::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("DataConnector"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->type); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("url", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->url); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.description) { + xfer += oprot->writeFieldBegin("description", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->description); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.parameters) { + xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 5); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); + std::map ::const_iterator _iter821; + for (_iter821 = this->parameters.begin(); _iter821 != this->parameters.end(); ++_iter821) + { + xfer += oprot->writeString(_iter821->first); + xfer += oprot->writeString(_iter821->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ownerName) { + xfer += oprot->writeFieldBegin("ownerName", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->ownerName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ownerType) { + xfer += oprot->writeFieldBegin("ownerType", ::apache::thrift::protocol::T_I32, 7); + xfer += oprot->writeI32(static_cast(this->ownerType)); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.createTime) { + xfer += oprot->writeFieldBegin("createTime", ::apache::thrift::protocol::T_I32, 8); + xfer += oprot->writeI32(this->createTime); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(DataConnector &a, DataConnector &b) noexcept { + using ::std::swap; + swap(a.name, b.name); + swap(a.type, b.type); + swap(a.url, b.url); + swap(a.description, b.description); + swap(a.parameters, b.parameters); + swap(a.ownerName, b.ownerName); + swap(a.ownerType, b.ownerType); + swap(a.createTime, b.createTime); + swap(a.__isset, b.__isset); +} + +bool DataConnector::operator==(const DataConnector & rhs) const +{ + if (!(name == rhs.name)) + return false; + if (!(type == rhs.type)) + return false; + if (!(url == rhs.url)) + return false; + if (__isset.description != rhs.__isset.description) + return false; + else if (__isset.description && !(description == rhs.description)) + return false; + if (__isset.parameters != rhs.__isset.parameters) + return false; + else if (__isset.parameters && !(parameters == rhs.parameters)) + return false; + if (__isset.ownerName != rhs.__isset.ownerName) + return false; + else if (__isset.ownerName && !(ownerName == rhs.ownerName)) + return false; + if (__isset.ownerType != rhs.__isset.ownerType) + return false; + else if (__isset.ownerType && !(ownerType == rhs.ownerType)) + return false; + if (__isset.createTime != rhs.__isset.createTime) + return false; + else if (__isset.createTime && !(createTime == rhs.createTime)) + return false; + return true; +} + +DataConnector::DataConnector(const DataConnector& other822) { + name = other822.name; + type = other822.type; + url = other822.url; + description = other822.description; + parameters = other822.parameters; + ownerName = other822.ownerName; + ownerType = other822.ownerType; + createTime = other822.createTime; + __isset = other822.__isset; +} +DataConnector& DataConnector::operator=(const DataConnector& other823) { + name = other823.name; + type = other823.type; + url = other823.url; + description = other823.description; + parameters = other823.parameters; + ownerName = other823.ownerName; + ownerType = other823.ownerType; + createTime = other823.createTime; + __isset = other823.__isset; + return *this; +} +void DataConnector::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "DataConnector("; + out << "name=" << to_string(name); + out << ", " << "type=" << to_string(type); + out << ", " << "url=" << to_string(url); + out << ", " << "description="; (__isset.description ? (out << to_string(description)) : (out << "")); + out << ", " << "parameters="; (__isset.parameters ? (out << to_string(parameters)) : (out << "")); + out << ", " << "ownerName="; (__isset.ownerName ? (out << to_string(ownerName)) : (out << "")); + out << ", " << "ownerType="; (__isset.ownerType ? (out << to_string(ownerType)) : (out << "")); + out << ", " << "createTime="; (__isset.createTime ? (out << to_string(createTime)) : (out << "")); + out << ")"; +} + + +ResourceUri::~ResourceUri() noexcept { +} + +ResourceUri::ResourceUri() noexcept + : resourceType(static_cast(0)), + uri() { +} + +void ResourceUri::__set_resourceType(const ResourceType::type val) { + this->resourceType = val; +} + +void ResourceUri::__set_uri(const std::string& val) { + this->uri = val; +} +std::ostream& operator<<(std::ostream& out, const ResourceUri& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ResourceUri::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast824; + xfer += iprot->readI32(ecast824); + this->resourceType = static_cast(ecast824); + this->__isset.resourceType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->uri); + this->__isset.uri = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ResourceUri::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ResourceUri"); + + xfer += oprot->writeFieldBegin("resourceType", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32(static_cast(this->resourceType)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("uri", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->uri); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ResourceUri &a, ResourceUri &b) noexcept { + using ::std::swap; + swap(a.resourceType, b.resourceType); + swap(a.uri, b.uri); + swap(a.__isset, b.__isset); +} + +bool ResourceUri::operator==(const ResourceUri & rhs) const +{ + if (!(resourceType == rhs.resourceType)) + return false; + if (!(uri == rhs.uri)) + return false; + return true; +} + +ResourceUri::ResourceUri(const ResourceUri& other825) { + resourceType = other825.resourceType; + uri = other825.uri; + __isset = other825.__isset; +} +ResourceUri& ResourceUri::operator=(const ResourceUri& other826) { + resourceType = other826.resourceType; + uri = other826.uri; + __isset = other826.__isset; + return *this; +} +void ResourceUri::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ResourceUri("; + out << "resourceType=" << to_string(resourceType); + out << ", " << "uri=" << to_string(uri); + out << ")"; +} + + +Function::~Function() noexcept { +} + +Function::Function() noexcept + : functionName(), + dbName(), + className(), + ownerName(), + ownerType(static_cast(0)), + createTime(0), + functionType(static_cast(0)), + catName() { +} + +void Function::__set_functionName(const std::string& val) { + this->functionName = val; +} + +void Function::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void Function::__set_className(const std::string& val) { + this->className = val; +} + +void Function::__set_ownerName(const std::string& val) { + this->ownerName = val; +} + +void Function::__set_ownerType(const PrincipalType::type val) { + this->ownerType = val; +} + +void Function::__set_createTime(const int32_t val) { + this->createTime = val; +} + +void Function::__set_functionType(const FunctionType::type val) { + this->functionType = val; +} + +void Function::__set_resourceUris(const std::vector & val) { + this->resourceUris = val; +} + +void Function::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} +std::ostream& operator<<(std::ostream& out, const Function& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->functionName); + this->__isset.functionName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->className); + this->__isset.className = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ownerName); + this->__isset.ownerName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast827; + xfer += iprot->readI32(ecast827); + this->ownerType = static_cast(ecast827); + this->__isset.ownerType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->createTime); + this->__isset.createTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast828; + xfer += iprot->readI32(ecast828); + this->functionType = static_cast(ecast828); + this->__isset.functionType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->resourceUris.clear(); + uint32_t _size829; + ::apache::thrift::protocol::TType _etype832; + xfer += iprot->readListBegin(_etype832, _size829); + this->resourceUris.resize(_size829); + uint32_t _i833; + for (_i833 = 0; _i833 < _size829; ++_i833) + { + xfer += this->resourceUris[_i833].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.resourceUris = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Function::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Function"); + + xfer += oprot->writeFieldBegin("functionName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->functionName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("className", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->className); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("ownerName", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->ownerName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("ownerType", ::apache::thrift::protocol::T_I32, 5); + xfer += oprot->writeI32(static_cast(this->ownerType)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("createTime", ::apache::thrift::protocol::T_I32, 6); + xfer += oprot->writeI32(this->createTime); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("functionType", ::apache::thrift::protocol::T_I32, 7); + xfer += oprot->writeI32(static_cast(this->functionType)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("resourceUris", ::apache::thrift::protocol::T_LIST, 8); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->resourceUris.size())); + std::vector ::const_iterator _iter834; + for (_iter834 = this->resourceUris.begin(); _iter834 != this->resourceUris.end(); ++_iter834) + { + xfer += (*_iter834).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 9); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Function &a, Function &b) noexcept { + using ::std::swap; + swap(a.functionName, b.functionName); + swap(a.dbName, b.dbName); + swap(a.className, b.className); + swap(a.ownerName, b.ownerName); + swap(a.ownerType, b.ownerType); + swap(a.createTime, b.createTime); + swap(a.functionType, b.functionType); + swap(a.resourceUris, b.resourceUris); + swap(a.catName, b.catName); + swap(a.__isset, b.__isset); +} + +bool Function::operator==(const Function & rhs) const +{ + if (!(functionName == rhs.functionName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(className == rhs.className)) + return false; + if (!(ownerName == rhs.ownerName)) + return false; + if (!(ownerType == rhs.ownerType)) + return false; + if (!(createTime == rhs.createTime)) + return false; + if (!(functionType == rhs.functionType)) + return false; + if (!(resourceUris == rhs.resourceUris)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + return true; +} + +Function::Function(const Function& other835) { + functionName = other835.functionName; + dbName = other835.dbName; + className = other835.className; + ownerName = other835.ownerName; + ownerType = other835.ownerType; + createTime = other835.createTime; + functionType = other835.functionType; + resourceUris = other835.resourceUris; + catName = other835.catName; + __isset = other835.__isset; +} +Function& Function::operator=(const Function& other836) { + functionName = other836.functionName; + dbName = other836.dbName; + className = other836.className; + ownerName = other836.ownerName; + ownerType = other836.ownerType; + createTime = other836.createTime; + functionType = other836.functionType; + resourceUris = other836.resourceUris; + catName = other836.catName; + __isset = other836.__isset; + return *this; +} +void Function::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Function("; + out << "functionName=" << to_string(functionName); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "className=" << to_string(className); + out << ", " << "ownerName=" << to_string(ownerName); + out << ", " << "ownerType=" << to_string(ownerType); + out << ", " << "createTime=" << to_string(createTime); + out << ", " << "functionType=" << to_string(functionType); + out << ", " << "resourceUris=" << to_string(resourceUris); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ")"; +} + + +TxnInfo::~TxnInfo() noexcept { +} + +TxnInfo::TxnInfo() : id(0), + state(static_cast(0)), + user(), + hostname(), + agentInfo("Unknown"), + heartbeatCount(0), + metaInfo(), + startedTime(0), + lastHeartbeatTime(0) { +} + +void TxnInfo::__set_id(const int64_t val) { + this->id = val; +} + +void TxnInfo::__set_state(const TxnState::type val) { + this->state = val; +} + +void TxnInfo::__set_user(const std::string& val) { + this->user = val; +} + +void TxnInfo::__set_hostname(const std::string& val) { + this->hostname = val; +} + +void TxnInfo::__set_agentInfo(const std::string& val) { + this->agentInfo = val; +__isset.agentInfo = true; +} + +void TxnInfo::__set_heartbeatCount(const int32_t val) { + this->heartbeatCount = val; +__isset.heartbeatCount = true; +} + +void TxnInfo::__set_metaInfo(const std::string& val) { + this->metaInfo = val; +__isset.metaInfo = true; +} + +void TxnInfo::__set_startedTime(const int64_t val) { + this->startedTime = val; +__isset.startedTime = true; +} + +void TxnInfo::__set_lastHeartbeatTime(const int64_t val) { + this->lastHeartbeatTime = val; +__isset.lastHeartbeatTime = true; +} +std::ostream& operator<<(std::ostream& out, const TxnInfo& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t TxnInfo::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_id = false; + bool isset_state = false; + bool isset_user = false; + bool isset_hostname = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->id); + isset_id = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast837; + xfer += iprot->readI32(ecast837); + this->state = static_cast(ecast837); + isset_state = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->user); + isset_user = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->hostname); + isset_hostname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->agentInfo); + this->__isset.agentInfo = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->heartbeatCount); + this->__isset.heartbeatCount = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->metaInfo); + this->__isset.metaInfo = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->startedTime); + this->__isset.startedTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->lastHeartbeatTime); + this->__isset.lastHeartbeatTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_id) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_state) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_user) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_hostname) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t TxnInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("TxnInfo"); + + xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->id); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(static_cast(this->state)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("user", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->user); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("hostname", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->hostname); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.agentInfo) { + xfer += oprot->writeFieldBegin("agentInfo", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->agentInfo); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.heartbeatCount) { + xfer += oprot->writeFieldBegin("heartbeatCount", ::apache::thrift::protocol::T_I32, 6); + xfer += oprot->writeI32(this->heartbeatCount); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.metaInfo) { + xfer += oprot->writeFieldBegin("metaInfo", ::apache::thrift::protocol::T_STRING, 7); + xfer += oprot->writeString(this->metaInfo); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.startedTime) { + xfer += oprot->writeFieldBegin("startedTime", ::apache::thrift::protocol::T_I64, 8); + xfer += oprot->writeI64(this->startedTime); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.lastHeartbeatTime) { + xfer += oprot->writeFieldBegin("lastHeartbeatTime", ::apache::thrift::protocol::T_I64, 9); + xfer += oprot->writeI64(this->lastHeartbeatTime); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(TxnInfo &a, TxnInfo &b) noexcept { + using ::std::swap; + swap(a.id, b.id); + swap(a.state, b.state); + swap(a.user, b.user); + swap(a.hostname, b.hostname); + swap(a.agentInfo, b.agentInfo); + swap(a.heartbeatCount, b.heartbeatCount); + swap(a.metaInfo, b.metaInfo); + swap(a.startedTime, b.startedTime); + swap(a.lastHeartbeatTime, b.lastHeartbeatTime); + swap(a.__isset, b.__isset); +} + +bool TxnInfo::operator==(const TxnInfo & rhs) const +{ + if (!(id == rhs.id)) + return false; + if (!(state == rhs.state)) + return false; + if (!(user == rhs.user)) + return false; + if (!(hostname == rhs.hostname)) + return false; + if (__isset.agentInfo != rhs.__isset.agentInfo) + return false; + else if (__isset.agentInfo && !(agentInfo == rhs.agentInfo)) + return false; + if (__isset.heartbeatCount != rhs.__isset.heartbeatCount) + return false; + else if (__isset.heartbeatCount && !(heartbeatCount == rhs.heartbeatCount)) + return false; + if (__isset.metaInfo != rhs.__isset.metaInfo) + return false; + else if (__isset.metaInfo && !(metaInfo == rhs.metaInfo)) + return false; + if (__isset.startedTime != rhs.__isset.startedTime) + return false; + else if (__isset.startedTime && !(startedTime == rhs.startedTime)) + return false; + if (__isset.lastHeartbeatTime != rhs.__isset.lastHeartbeatTime) + return false; + else if (__isset.lastHeartbeatTime && !(lastHeartbeatTime == rhs.lastHeartbeatTime)) + return false; + return true; +} + +TxnInfo::TxnInfo(const TxnInfo& other838) { + id = other838.id; + state = other838.state; + user = other838.user; + hostname = other838.hostname; + agentInfo = other838.agentInfo; + heartbeatCount = other838.heartbeatCount; + metaInfo = other838.metaInfo; + startedTime = other838.startedTime; + lastHeartbeatTime = other838.lastHeartbeatTime; + __isset = other838.__isset; +} +TxnInfo& TxnInfo::operator=(const TxnInfo& other839) { + id = other839.id; + state = other839.state; + user = other839.user; + hostname = other839.hostname; + agentInfo = other839.agentInfo; + heartbeatCount = other839.heartbeatCount; + metaInfo = other839.metaInfo; + startedTime = other839.startedTime; + lastHeartbeatTime = other839.lastHeartbeatTime; + __isset = other839.__isset; + return *this; +} +void TxnInfo::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "TxnInfo("; + out << "id=" << to_string(id); + out << ", " << "state=" << to_string(state); + out << ", " << "user=" << to_string(user); + out << ", " << "hostname=" << to_string(hostname); + out << ", " << "agentInfo="; (__isset.agentInfo ? (out << to_string(agentInfo)) : (out << "")); + out << ", " << "heartbeatCount="; (__isset.heartbeatCount ? (out << to_string(heartbeatCount)) : (out << "")); + out << ", " << "metaInfo="; (__isset.metaInfo ? (out << to_string(metaInfo)) : (out << "")); + out << ", " << "startedTime="; (__isset.startedTime ? (out << to_string(startedTime)) : (out << "")); + out << ", " << "lastHeartbeatTime="; (__isset.lastHeartbeatTime ? (out << to_string(lastHeartbeatTime)) : (out << "")); + out << ")"; +} + + +GetOpenTxnsInfoResponse::~GetOpenTxnsInfoResponse() noexcept { +} + +GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse() noexcept + : txn_high_water_mark(0) { +} + +void GetOpenTxnsInfoResponse::__set_txn_high_water_mark(const int64_t val) { + this->txn_high_water_mark = val; +} + +void GetOpenTxnsInfoResponse::__set_open_txns(const std::vector & val) { + this->open_txns = val; +} +std::ostream& operator<<(std::ostream& out, const GetOpenTxnsInfoResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetOpenTxnsInfoResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_txn_high_water_mark = false; + bool isset_open_txns = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txn_high_water_mark); + isset_txn_high_water_mark = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->open_txns.clear(); + uint32_t _size840; + ::apache::thrift::protocol::TType _etype843; + xfer += iprot->readListBegin(_etype843, _size840); + this->open_txns.resize(_size840); + uint32_t _i844; + for (_i844 = 0; _i844 < _size840; ++_i844) + { + xfer += this->open_txns[_i844].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_open_txns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_txn_high_water_mark) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_open_txns) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetOpenTxnsInfoResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetOpenTxnsInfoResponse"); + + xfer += oprot->writeFieldBegin("txn_high_water_mark", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->txn_high_water_mark); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->open_txns.size())); + std::vector ::const_iterator _iter845; + for (_iter845 = this->open_txns.begin(); _iter845 != this->open_txns.end(); ++_iter845) + { + xfer += (*_iter845).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetOpenTxnsInfoResponse &a, GetOpenTxnsInfoResponse &b) noexcept { + using ::std::swap; + swap(a.txn_high_water_mark, b.txn_high_water_mark); + swap(a.open_txns, b.open_txns); +} + +bool GetOpenTxnsInfoResponse::operator==(const GetOpenTxnsInfoResponse & rhs) const +{ + if (!(txn_high_water_mark == rhs.txn_high_water_mark)) + return false; + if (!(open_txns == rhs.open_txns)) + return false; + return true; +} + +GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse& other846) { + txn_high_water_mark = other846.txn_high_water_mark; + open_txns = other846.open_txns; +} +GetOpenTxnsInfoResponse& GetOpenTxnsInfoResponse::operator=(const GetOpenTxnsInfoResponse& other847) { + txn_high_water_mark = other847.txn_high_water_mark; + open_txns = other847.open_txns; + return *this; +} +void GetOpenTxnsInfoResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetOpenTxnsInfoResponse("; + out << "txn_high_water_mark=" << to_string(txn_high_water_mark); + out << ", " << "open_txns=" << to_string(open_txns); + out << ")"; +} + + +GetOpenTxnsResponse::~GetOpenTxnsResponse() noexcept { +} + +GetOpenTxnsResponse::GetOpenTxnsResponse() noexcept + : txn_high_water_mark(0), + min_open_txn(0), + abortedBits() { +} + +void GetOpenTxnsResponse::__set_txn_high_water_mark(const int64_t val) { + this->txn_high_water_mark = val; +} + +void GetOpenTxnsResponse::__set_open_txns(const std::vector & val) { + this->open_txns = val; +} + +void GetOpenTxnsResponse::__set_min_open_txn(const int64_t val) { + this->min_open_txn = val; +__isset.min_open_txn = true; +} + +void GetOpenTxnsResponse::__set_abortedBits(const std::string& val) { + this->abortedBits = val; +} +std::ostream& operator<<(std::ostream& out, const GetOpenTxnsResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_txn_high_water_mark = false; + bool isset_open_txns = false; + bool isset_abortedBits = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txn_high_water_mark); + isset_txn_high_water_mark = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->open_txns.clear(); + uint32_t _size848; + ::apache::thrift::protocol::TType _etype851; + xfer += iprot->readListBegin(_etype851, _size848); + this->open_txns.resize(_size848); + uint32_t _i852; + for (_i852 = 0; _i852 < _size848; ++_i852) + { + xfer += iprot->readI64(this->open_txns[_i852]); + } + xfer += iprot->readListEnd(); + } + isset_open_txns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->min_open_txn); + this->__isset.min_open_txn = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->abortedBits); + isset_abortedBits = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_txn_high_water_mark) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_open_txns) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_abortedBits) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetOpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetOpenTxnsResponse"); + + xfer += oprot->writeFieldBegin("txn_high_water_mark", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->txn_high_water_mark); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->open_txns.size())); + std::vector ::const_iterator _iter853; + for (_iter853 = this->open_txns.begin(); _iter853 != this->open_txns.end(); ++_iter853) + { + xfer += oprot->writeI64((*_iter853)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.min_open_txn) { + xfer += oprot->writeFieldBegin("min_open_txn", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->min_open_txn); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("abortedBits", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeBinary(this->abortedBits); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetOpenTxnsResponse &a, GetOpenTxnsResponse &b) noexcept { + using ::std::swap; + swap(a.txn_high_water_mark, b.txn_high_water_mark); + swap(a.open_txns, b.open_txns); + swap(a.min_open_txn, b.min_open_txn); + swap(a.abortedBits, b.abortedBits); + swap(a.__isset, b.__isset); +} + +bool GetOpenTxnsResponse::operator==(const GetOpenTxnsResponse & rhs) const +{ + if (!(txn_high_water_mark == rhs.txn_high_water_mark)) + return false; + if (!(open_txns == rhs.open_txns)) + return false; + if (__isset.min_open_txn != rhs.__isset.min_open_txn) + return false; + else if (__isset.min_open_txn && !(min_open_txn == rhs.min_open_txn)) + return false; + if (!(abortedBits == rhs.abortedBits)) + return false; + return true; +} + +GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other854) { + txn_high_water_mark = other854.txn_high_water_mark; + open_txns = other854.open_txns; + min_open_txn = other854.min_open_txn; + abortedBits = other854.abortedBits; + __isset = other854.__isset; +} +GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other855) { + txn_high_water_mark = other855.txn_high_water_mark; + open_txns = other855.open_txns; + min_open_txn = other855.min_open_txn; + abortedBits = other855.abortedBits; + __isset = other855.__isset; + return *this; +} +void GetOpenTxnsResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetOpenTxnsResponse("; + out << "txn_high_water_mark=" << to_string(txn_high_water_mark); + out << ", " << "open_txns=" << to_string(open_txns); + out << ", " << "min_open_txn="; (__isset.min_open_txn ? (out << to_string(min_open_txn)) : (out << "")); + out << ", " << "abortedBits=" << to_string(abortedBits); + out << ")"; +} + + +OpenTxnRequest::~OpenTxnRequest() noexcept { +} + +OpenTxnRequest::OpenTxnRequest() : num_txns(0), + user(), + hostname(), + agentInfo("Unknown"), + replPolicy(), + txn_type(static_cast(0)) { +} + +void OpenTxnRequest::__set_num_txns(const int32_t val) { + this->num_txns = val; +} + +void OpenTxnRequest::__set_user(const std::string& val) { + this->user = val; +} + +void OpenTxnRequest::__set_hostname(const std::string& val) { + this->hostname = val; +} + +void OpenTxnRequest::__set_agentInfo(const std::string& val) { + this->agentInfo = val; +__isset.agentInfo = true; +} + +void OpenTxnRequest::__set_replPolicy(const std::string& val) { + this->replPolicy = val; +__isset.replPolicy = true; +} + +void OpenTxnRequest::__set_replSrcTxnIds(const std::vector & val) { + this->replSrcTxnIds = val; +__isset.replSrcTxnIds = true; +} + +void OpenTxnRequest::__set_txn_type(const TxnType::type val) { + this->txn_type = val; +__isset.txn_type = true; +} +std::ostream& operator<<(std::ostream& out, const OpenTxnRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t OpenTxnRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_num_txns = false; + bool isset_user = false; + bool isset_hostname = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->num_txns); + isset_num_txns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->user); + isset_user = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->hostname); + isset_hostname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->agentInfo); + this->__isset.agentInfo = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->replPolicy); + this->__isset.replPolicy = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->replSrcTxnIds.clear(); + uint32_t _size856; + ::apache::thrift::protocol::TType _etype859; + xfer += iprot->readListBegin(_etype859, _size856); + this->replSrcTxnIds.resize(_size856); + uint32_t _i860; + for (_i860 = 0; _i860 < _size856; ++_i860) + { + xfer += iprot->readI64(this->replSrcTxnIds[_i860]); + } + xfer += iprot->readListEnd(); + } + this->__isset.replSrcTxnIds = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast861; + xfer += iprot->readI32(ecast861); + this->txn_type = static_cast(ecast861); + this->__isset.txn_type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_num_txns) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_user) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_hostname) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t OpenTxnRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("OpenTxnRequest"); + + xfer += oprot->writeFieldBegin("num_txns", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32(this->num_txns); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("user", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->user); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("hostname", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->hostname); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.agentInfo) { + xfer += oprot->writeFieldBegin("agentInfo", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->agentInfo); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.replPolicy) { + xfer += oprot->writeFieldBegin("replPolicy", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->replPolicy); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.replSrcTxnIds) { + xfer += oprot->writeFieldBegin("replSrcTxnIds", ::apache::thrift::protocol::T_LIST, 6); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->replSrcTxnIds.size())); + std::vector ::const_iterator _iter862; + for (_iter862 = this->replSrcTxnIds.begin(); _iter862 != this->replSrcTxnIds.end(); ++_iter862) + { + xfer += oprot->writeI64((*_iter862)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.txn_type) { + xfer += oprot->writeFieldBegin("txn_type", ::apache::thrift::protocol::T_I32, 7); + xfer += oprot->writeI32(static_cast(this->txn_type)); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(OpenTxnRequest &a, OpenTxnRequest &b) noexcept { + using ::std::swap; + swap(a.num_txns, b.num_txns); + swap(a.user, b.user); + swap(a.hostname, b.hostname); + swap(a.agentInfo, b.agentInfo); + swap(a.replPolicy, b.replPolicy); + swap(a.replSrcTxnIds, b.replSrcTxnIds); + swap(a.txn_type, b.txn_type); + swap(a.__isset, b.__isset); +} + +bool OpenTxnRequest::operator==(const OpenTxnRequest & rhs) const +{ + if (!(num_txns == rhs.num_txns)) + return false; + if (!(user == rhs.user)) + return false; + if (!(hostname == rhs.hostname)) + return false; + if (__isset.agentInfo != rhs.__isset.agentInfo) + return false; + else if (__isset.agentInfo && !(agentInfo == rhs.agentInfo)) + return false; + if (__isset.replPolicy != rhs.__isset.replPolicy) + return false; + else if (__isset.replPolicy && !(replPolicy == rhs.replPolicy)) + return false; + if (__isset.replSrcTxnIds != rhs.__isset.replSrcTxnIds) + return false; + else if (__isset.replSrcTxnIds && !(replSrcTxnIds == rhs.replSrcTxnIds)) + return false; + if (__isset.txn_type != rhs.__isset.txn_type) + return false; + else if (__isset.txn_type && !(txn_type == rhs.txn_type)) + return false; + return true; +} + +OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other863) { + num_txns = other863.num_txns; + user = other863.user; + hostname = other863.hostname; + agentInfo = other863.agentInfo; + replPolicy = other863.replPolicy; + replSrcTxnIds = other863.replSrcTxnIds; + txn_type = other863.txn_type; + __isset = other863.__isset; +} +OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other864) { + num_txns = other864.num_txns; + user = other864.user; + hostname = other864.hostname; + agentInfo = other864.agentInfo; + replPolicy = other864.replPolicy; + replSrcTxnIds = other864.replSrcTxnIds; + txn_type = other864.txn_type; + __isset = other864.__isset; + return *this; +} +void OpenTxnRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "OpenTxnRequest("; + out << "num_txns=" << to_string(num_txns); + out << ", " << "user=" << to_string(user); + out << ", " << "hostname=" << to_string(hostname); + out << ", " << "agentInfo="; (__isset.agentInfo ? (out << to_string(agentInfo)) : (out << "")); + out << ", " << "replPolicy="; (__isset.replPolicy ? (out << to_string(replPolicy)) : (out << "")); + out << ", " << "replSrcTxnIds="; (__isset.replSrcTxnIds ? (out << to_string(replSrcTxnIds)) : (out << "")); + out << ", " << "txn_type="; (__isset.txn_type ? (out << to_string(txn_type)) : (out << "")); + out << ")"; +} + + +OpenTxnsResponse::~OpenTxnsResponse() noexcept { +} + +OpenTxnsResponse::OpenTxnsResponse() noexcept { +} + +void OpenTxnsResponse::__set_txn_ids(const std::vector & val) { + this->txn_ids = val; +} +std::ostream& operator<<(std::ostream& out, const OpenTxnsResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t OpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_txn_ids = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->txn_ids.clear(); + uint32_t _size865; + ::apache::thrift::protocol::TType _etype868; + xfer += iprot->readListBegin(_etype868, _size865); + this->txn_ids.resize(_size865); + uint32_t _i869; + for (_i869 = 0; _i869 < _size865; ++_i869) + { + xfer += iprot->readI64(this->txn_ids[_i869]); + } + xfer += iprot->readListEnd(); + } + isset_txn_ids = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_txn_ids) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t OpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("OpenTxnsResponse"); + + xfer += oprot->writeFieldBegin("txn_ids", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->txn_ids.size())); + std::vector ::const_iterator _iter870; + for (_iter870 = this->txn_ids.begin(); _iter870 != this->txn_ids.end(); ++_iter870) + { + xfer += oprot->writeI64((*_iter870)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(OpenTxnsResponse &a, OpenTxnsResponse &b) noexcept { + using ::std::swap; + swap(a.txn_ids, b.txn_ids); +} + +bool OpenTxnsResponse::operator==(const OpenTxnsResponse & rhs) const +{ + if (!(txn_ids == rhs.txn_ids)) + return false; + return true; +} + +OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other871) { + txn_ids = other871.txn_ids; +} +OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other872) { + txn_ids = other872.txn_ids; + return *this; +} +void OpenTxnsResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "OpenTxnsResponse("; + out << "txn_ids=" << to_string(txn_ids); + out << ")"; +} + + +AbortTxnRequest::~AbortTxnRequest() noexcept { +} + +AbortTxnRequest::AbortTxnRequest() noexcept + : txnid(0), + replPolicy(), + txn_type(static_cast(0)), + errorCode(0) { +} + +void AbortTxnRequest::__set_txnid(const int64_t val) { + this->txnid = val; +} + +void AbortTxnRequest::__set_replPolicy(const std::string& val) { + this->replPolicy = val; +__isset.replPolicy = true; +} + +void AbortTxnRequest::__set_txn_type(const TxnType::type val) { + this->txn_type = val; +__isset.txn_type = true; +} + +void AbortTxnRequest::__set_errorCode(const int64_t val) { + this->errorCode = val; +__isset.errorCode = true; +} +std::ostream& operator<<(std::ostream& out, const AbortTxnRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AbortTxnRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_txnid = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnid); + isset_txnid = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->replPolicy); + this->__isset.replPolicy = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast873; + xfer += iprot->readI32(ecast873); + this->txn_type = static_cast(ecast873); + this->__isset.txn_type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->errorCode); + this->__isset.errorCode = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_txnid) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AbortTxnRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AbortTxnRequest"); + + xfer += oprot->writeFieldBegin("txnid", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->txnid); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.replPolicy) { + xfer += oprot->writeFieldBegin("replPolicy", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->replPolicy); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.txn_type) { + xfer += oprot->writeFieldBegin("txn_type", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32(static_cast(this->txn_type)); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.errorCode) { + xfer += oprot->writeFieldBegin("errorCode", ::apache::thrift::protocol::T_I64, 4); + xfer += oprot->writeI64(this->errorCode); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AbortTxnRequest &a, AbortTxnRequest &b) noexcept { + using ::std::swap; + swap(a.txnid, b.txnid); + swap(a.replPolicy, b.replPolicy); + swap(a.txn_type, b.txn_type); + swap(a.errorCode, b.errorCode); + swap(a.__isset, b.__isset); +} + +bool AbortTxnRequest::operator==(const AbortTxnRequest & rhs) const +{ + if (!(txnid == rhs.txnid)) + return false; + if (__isset.replPolicy != rhs.__isset.replPolicy) + return false; + else if (__isset.replPolicy && !(replPolicy == rhs.replPolicy)) + return false; + if (__isset.txn_type != rhs.__isset.txn_type) + return false; + else if (__isset.txn_type && !(txn_type == rhs.txn_type)) + return false; + if (__isset.errorCode != rhs.__isset.errorCode) + return false; + else if (__isset.errorCode && !(errorCode == rhs.errorCode)) + return false; + return true; +} + +AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other874) { + txnid = other874.txnid; + replPolicy = other874.replPolicy; + txn_type = other874.txn_type; + errorCode = other874.errorCode; + __isset = other874.__isset; +} +AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other875) { + txnid = other875.txnid; + replPolicy = other875.replPolicy; + txn_type = other875.txn_type; + errorCode = other875.errorCode; + __isset = other875.__isset; + return *this; +} +void AbortTxnRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AbortTxnRequest("; + out << "txnid=" << to_string(txnid); + out << ", " << "replPolicy="; (__isset.replPolicy ? (out << to_string(replPolicy)) : (out << "")); + out << ", " << "txn_type="; (__isset.txn_type ? (out << to_string(txn_type)) : (out << "")); + out << ", " << "errorCode="; (__isset.errorCode ? (out << to_string(errorCode)) : (out << "")); + out << ")"; +} + + +AbortTxnsRequest::~AbortTxnsRequest() noexcept { +} + +AbortTxnsRequest::AbortTxnsRequest() noexcept + : errorCode(0) { +} + +void AbortTxnsRequest::__set_txn_ids(const std::vector & val) { + this->txn_ids = val; +} + +void AbortTxnsRequest::__set_errorCode(const int64_t val) { + this->errorCode = val; +__isset.errorCode = true; +} +std::ostream& operator<<(std::ostream& out, const AbortTxnsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AbortTxnsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_txn_ids = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->txn_ids.clear(); + uint32_t _size876; + ::apache::thrift::protocol::TType _etype879; + xfer += iprot->readListBegin(_etype879, _size876); + this->txn_ids.resize(_size876); + uint32_t _i880; + for (_i880 = 0; _i880 < _size876; ++_i880) + { + xfer += iprot->readI64(this->txn_ids[_i880]); + } + xfer += iprot->readListEnd(); + } + isset_txn_ids = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->errorCode); + this->__isset.errorCode = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_txn_ids) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AbortTxnsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AbortTxnsRequest"); + + xfer += oprot->writeFieldBegin("txn_ids", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->txn_ids.size())); + std::vector ::const_iterator _iter881; + for (_iter881 = this->txn_ids.begin(); _iter881 != this->txn_ids.end(); ++_iter881) + { + xfer += oprot->writeI64((*_iter881)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.errorCode) { + xfer += oprot->writeFieldBegin("errorCode", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->errorCode); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AbortTxnsRequest &a, AbortTxnsRequest &b) noexcept { + using ::std::swap; + swap(a.txn_ids, b.txn_ids); + swap(a.errorCode, b.errorCode); + swap(a.__isset, b.__isset); +} + +bool AbortTxnsRequest::operator==(const AbortTxnsRequest & rhs) const +{ + if (!(txn_ids == rhs.txn_ids)) + return false; + if (__isset.errorCode != rhs.__isset.errorCode) + return false; + else if (__isset.errorCode && !(errorCode == rhs.errorCode)) + return false; + return true; +} + +AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other882) { + txn_ids = other882.txn_ids; + errorCode = other882.errorCode; + __isset = other882.__isset; +} +AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other883) { + txn_ids = other883.txn_ids; + errorCode = other883.errorCode; + __isset = other883.__isset; + return *this; +} +void AbortTxnsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AbortTxnsRequest("; + out << "txn_ids=" << to_string(txn_ids); + out << ", " << "errorCode="; (__isset.errorCode ? (out << to_string(errorCode)) : (out << "")); + out << ")"; +} + + +CommitTxnKeyValue::~CommitTxnKeyValue() noexcept { +} + +CommitTxnKeyValue::CommitTxnKeyValue() noexcept + : tableId(0), + key(), + value() { +} + +void CommitTxnKeyValue::__set_tableId(const int64_t val) { + this->tableId = val; +} + +void CommitTxnKeyValue::__set_key(const std::string& val) { + this->key = val; +} + +void CommitTxnKeyValue::__set_value(const std::string& val) { + this->value = val; +} +std::ostream& operator<<(std::ostream& out, const CommitTxnKeyValue& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t CommitTxnKeyValue::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_tableId = false; + bool isset_key = false; + bool isset_value = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->tableId); + isset_tableId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->key); + isset_key = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->value); + isset_value = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_tableId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_key) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_value) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t CommitTxnKeyValue::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CommitTxnKeyValue"); + + xfer += oprot->writeFieldBegin("tableId", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->tableId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->key); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->value); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CommitTxnKeyValue &a, CommitTxnKeyValue &b) noexcept { + using ::std::swap; + swap(a.tableId, b.tableId); + swap(a.key, b.key); + swap(a.value, b.value); +} + +bool CommitTxnKeyValue::operator==(const CommitTxnKeyValue & rhs) const +{ + if (!(tableId == rhs.tableId)) + return false; + if (!(key == rhs.key)) + return false; + if (!(value == rhs.value)) + return false; + return true; +} + +CommitTxnKeyValue::CommitTxnKeyValue(const CommitTxnKeyValue& other884) { + tableId = other884.tableId; + key = other884.key; + value = other884.value; +} +CommitTxnKeyValue& CommitTxnKeyValue::operator=(const CommitTxnKeyValue& other885) { + tableId = other885.tableId; + key = other885.key; + value = other885.value; + return *this; +} +void CommitTxnKeyValue::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CommitTxnKeyValue("; + out << "tableId=" << to_string(tableId); + out << ", " << "key=" << to_string(key); + out << ", " << "value=" << to_string(value); + out << ")"; +} + + +WriteEventInfo::~WriteEventInfo() noexcept { +} + +WriteEventInfo::WriteEventInfo() noexcept + : writeId(0), + database(), + table(), + files(), + partition(), + tableObj(), + partitionObj() { +} + +void WriteEventInfo::__set_writeId(const int64_t val) { + this->writeId = val; +} + +void WriteEventInfo::__set_database(const std::string& val) { + this->database = val; +} + +void WriteEventInfo::__set_table(const std::string& val) { + this->table = val; +} + +void WriteEventInfo::__set_files(const std::string& val) { + this->files = val; +} + +void WriteEventInfo::__set_partition(const std::string& val) { + this->partition = val; +__isset.partition = true; +} + +void WriteEventInfo::__set_tableObj(const std::string& val) { + this->tableObj = val; +__isset.tableObj = true; +} + +void WriteEventInfo::__set_partitionObj(const std::string& val) { + this->partitionObj = val; +__isset.partitionObj = true; +} +std::ostream& operator<<(std::ostream& out, const WriteEventInfo& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WriteEventInfo::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_writeId = false; + bool isset_database = false; + bool isset_table = false; + bool isset_files = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->writeId); + isset_writeId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->database); + isset_database = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->table); + isset_table = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->files); + isset_files = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->partition); + this->__isset.partition = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableObj); + this->__isset.tableObj = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->partitionObj); + this->__isset.partitionObj = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_writeId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_database) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_table) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_files) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t WriteEventInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WriteEventInfo"); + + xfer += oprot->writeFieldBegin("writeId", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->writeId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("database", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->database); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->table); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("files", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->files); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.partition) { + xfer += oprot->writeFieldBegin("partition", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->partition); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.tableObj) { + xfer += oprot->writeFieldBegin("tableObj", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->tableObj); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.partitionObj) { + xfer += oprot->writeFieldBegin("partitionObj", ::apache::thrift::protocol::T_STRING, 7); + xfer += oprot->writeString(this->partitionObj); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WriteEventInfo &a, WriteEventInfo &b) noexcept { + using ::std::swap; + swap(a.writeId, b.writeId); + swap(a.database, b.database); + swap(a.table, b.table); + swap(a.files, b.files); + swap(a.partition, b.partition); + swap(a.tableObj, b.tableObj); + swap(a.partitionObj, b.partitionObj); + swap(a.__isset, b.__isset); +} + +bool WriteEventInfo::operator==(const WriteEventInfo & rhs) const +{ + if (!(writeId == rhs.writeId)) + return false; + if (!(database == rhs.database)) + return false; + if (!(table == rhs.table)) + return false; + if (!(files == rhs.files)) + return false; + if (__isset.partition != rhs.__isset.partition) + return false; + else if (__isset.partition && !(partition == rhs.partition)) + return false; + if (__isset.tableObj != rhs.__isset.tableObj) + return false; + else if (__isset.tableObj && !(tableObj == rhs.tableObj)) + return false; + if (__isset.partitionObj != rhs.__isset.partitionObj) + return false; + else if (__isset.partitionObj && !(partitionObj == rhs.partitionObj)) + return false; + return true; +} + +WriteEventInfo::WriteEventInfo(const WriteEventInfo& other886) { + writeId = other886.writeId; + database = other886.database; + table = other886.table; + files = other886.files; + partition = other886.partition; + tableObj = other886.tableObj; + partitionObj = other886.partitionObj; + __isset = other886.__isset; +} +WriteEventInfo& WriteEventInfo::operator=(const WriteEventInfo& other887) { + writeId = other887.writeId; + database = other887.database; + table = other887.table; + files = other887.files; + partition = other887.partition; + tableObj = other887.tableObj; + partitionObj = other887.partitionObj; + __isset = other887.__isset; + return *this; +} +void WriteEventInfo::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WriteEventInfo("; + out << "writeId=" << to_string(writeId); + out << ", " << "database=" << to_string(database); + out << ", " << "table=" << to_string(table); + out << ", " << "files=" << to_string(files); + out << ", " << "partition="; (__isset.partition ? (out << to_string(partition)) : (out << "")); + out << ", " << "tableObj="; (__isset.tableObj ? (out << to_string(tableObj)) : (out << "")); + out << ", " << "partitionObj="; (__isset.partitionObj ? (out << to_string(partitionObj)) : (out << "")); + out << ")"; +} + + +ReplLastIdInfo::~ReplLastIdInfo() noexcept { +} + +ReplLastIdInfo::ReplLastIdInfo() noexcept + : database(), + lastReplId(0), + table(), + catalog() { +} + +void ReplLastIdInfo::__set_database(const std::string& val) { + this->database = val; +} + +void ReplLastIdInfo::__set_lastReplId(const int64_t val) { + this->lastReplId = val; +} + +void ReplLastIdInfo::__set_table(const std::string& val) { + this->table = val; +__isset.table = true; +} + +void ReplLastIdInfo::__set_catalog(const std::string& val) { + this->catalog = val; +__isset.catalog = true; +} + +void ReplLastIdInfo::__set_partitionList(const std::vector & val) { + this->partitionList = val; +__isset.partitionList = true; +} +std::ostream& operator<<(std::ostream& out, const ReplLastIdInfo& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ReplLastIdInfo::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_database = false; + bool isset_lastReplId = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->database); + isset_database = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->lastReplId); + isset_lastReplId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->table); + this->__isset.table = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catalog); + this->__isset.catalog = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitionList.clear(); + uint32_t _size888; + ::apache::thrift::protocol::TType _etype891; + xfer += iprot->readListBegin(_etype891, _size888); + this->partitionList.resize(_size888); + uint32_t _i892; + for (_i892 = 0; _i892 < _size888; ++_i892) + { + xfer += iprot->readString(this->partitionList[_i892]); + } + xfer += iprot->readListEnd(); + } + this->__isset.partitionList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_database) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_lastReplId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ReplLastIdInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ReplLastIdInfo"); + + xfer += oprot->writeFieldBegin("database", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->database); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("lastReplId", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->lastReplId); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.table) { + xfer += oprot->writeFieldBegin("table", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->table); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.catalog) { + xfer += oprot->writeFieldBegin("catalog", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->catalog); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.partitionList) { + xfer += oprot->writeFieldBegin("partitionList", ::apache::thrift::protocol::T_LIST, 5); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionList.size())); + std::vector ::const_iterator _iter893; + for (_iter893 = this->partitionList.begin(); _iter893 != this->partitionList.end(); ++_iter893) + { + xfer += oprot->writeString((*_iter893)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ReplLastIdInfo &a, ReplLastIdInfo &b) noexcept { + using ::std::swap; + swap(a.database, b.database); + swap(a.lastReplId, b.lastReplId); + swap(a.table, b.table); + swap(a.catalog, b.catalog); + swap(a.partitionList, b.partitionList); + swap(a.__isset, b.__isset); +} + +bool ReplLastIdInfo::operator==(const ReplLastIdInfo & rhs) const +{ + if (!(database == rhs.database)) + return false; + if (!(lastReplId == rhs.lastReplId)) + return false; + if (__isset.table != rhs.__isset.table) + return false; + else if (__isset.table && !(table == rhs.table)) + return false; + if (__isset.catalog != rhs.__isset.catalog) + return false; + else if (__isset.catalog && !(catalog == rhs.catalog)) + return false; + if (__isset.partitionList != rhs.__isset.partitionList) + return false; + else if (__isset.partitionList && !(partitionList == rhs.partitionList)) + return false; + return true; +} + +ReplLastIdInfo::ReplLastIdInfo(const ReplLastIdInfo& other894) { + database = other894.database; + lastReplId = other894.lastReplId; + table = other894.table; + catalog = other894.catalog; + partitionList = other894.partitionList; + __isset = other894.__isset; +} +ReplLastIdInfo& ReplLastIdInfo::operator=(const ReplLastIdInfo& other895) { + database = other895.database; + lastReplId = other895.lastReplId; + table = other895.table; + catalog = other895.catalog; + partitionList = other895.partitionList; + __isset = other895.__isset; + return *this; +} +void ReplLastIdInfo::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ReplLastIdInfo("; + out << "database=" << to_string(database); + out << ", " << "lastReplId=" << to_string(lastReplId); + out << ", " << "table="; (__isset.table ? (out << to_string(table)) : (out << "")); + out << ", " << "catalog="; (__isset.catalog ? (out << to_string(catalog)) : (out << "")); + out << ", " << "partitionList="; (__isset.partitionList ? (out << to_string(partitionList)) : (out << "")); + out << ")"; +} + + +UpdateTransactionalStatsRequest::~UpdateTransactionalStatsRequest() noexcept { +} + +UpdateTransactionalStatsRequest::UpdateTransactionalStatsRequest() noexcept + : tableId(0), + insertCount(0), + updatedCount(0), + deletedCount(0) { +} + +void UpdateTransactionalStatsRequest::__set_tableId(const int64_t val) { + this->tableId = val; +} + +void UpdateTransactionalStatsRequest::__set_insertCount(const int64_t val) { + this->insertCount = val; +} + +void UpdateTransactionalStatsRequest::__set_updatedCount(const int64_t val) { + this->updatedCount = val; +} + +void UpdateTransactionalStatsRequest::__set_deletedCount(const int64_t val) { + this->deletedCount = val; +} +std::ostream& operator<<(std::ostream& out, const UpdateTransactionalStatsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t UpdateTransactionalStatsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_tableId = false; + bool isset_insertCount = false; + bool isset_updatedCount = false; + bool isset_deletedCount = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->tableId); + isset_tableId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->insertCount); + isset_insertCount = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->updatedCount); + isset_updatedCount = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->deletedCount); + isset_deletedCount = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_tableId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_insertCount) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_updatedCount) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_deletedCount) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t UpdateTransactionalStatsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("UpdateTransactionalStatsRequest"); + + xfer += oprot->writeFieldBegin("tableId", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->tableId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("insertCount", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->insertCount); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("updatedCount", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->updatedCount); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deletedCount", ::apache::thrift::protocol::T_I64, 4); + xfer += oprot->writeI64(this->deletedCount); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(UpdateTransactionalStatsRequest &a, UpdateTransactionalStatsRequest &b) noexcept { + using ::std::swap; + swap(a.tableId, b.tableId); + swap(a.insertCount, b.insertCount); + swap(a.updatedCount, b.updatedCount); + swap(a.deletedCount, b.deletedCount); +} + +bool UpdateTransactionalStatsRequest::operator==(const UpdateTransactionalStatsRequest & rhs) const +{ + if (!(tableId == rhs.tableId)) + return false; + if (!(insertCount == rhs.insertCount)) + return false; + if (!(updatedCount == rhs.updatedCount)) + return false; + if (!(deletedCount == rhs.deletedCount)) + return false; + return true; +} + +UpdateTransactionalStatsRequest::UpdateTransactionalStatsRequest(const UpdateTransactionalStatsRequest& other896) noexcept { + tableId = other896.tableId; + insertCount = other896.insertCount; + updatedCount = other896.updatedCount; + deletedCount = other896.deletedCount; +} +UpdateTransactionalStatsRequest& UpdateTransactionalStatsRequest::operator=(const UpdateTransactionalStatsRequest& other897) noexcept { + tableId = other897.tableId; + insertCount = other897.insertCount; + updatedCount = other897.updatedCount; + deletedCount = other897.deletedCount; + return *this; +} +void UpdateTransactionalStatsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "UpdateTransactionalStatsRequest("; + out << "tableId=" << to_string(tableId); + out << ", " << "insertCount=" << to_string(insertCount); + out << ", " << "updatedCount=" << to_string(updatedCount); + out << ", " << "deletedCount=" << to_string(deletedCount); + out << ")"; +} + + +CommitTxnRequest::~CommitTxnRequest() noexcept { +} + +CommitTxnRequest::CommitTxnRequest() noexcept + : txnid(0), + replPolicy(), + exclWriteEnabled(true), + txn_type(static_cast(0)) { +} + +void CommitTxnRequest::__set_txnid(const int64_t val) { + this->txnid = val; +} + +void CommitTxnRequest::__set_replPolicy(const std::string& val) { + this->replPolicy = val; +__isset.replPolicy = true; +} + +void CommitTxnRequest::__set_writeEventInfos(const std::vector & val) { + this->writeEventInfos = val; +__isset.writeEventInfos = true; +} + +void CommitTxnRequest::__set_replLastIdInfo(const ReplLastIdInfo& val) { + this->replLastIdInfo = val; +__isset.replLastIdInfo = true; +} + +void CommitTxnRequest::__set_keyValue(const CommitTxnKeyValue& val) { + this->keyValue = val; +__isset.keyValue = true; +} + +void CommitTxnRequest::__set_exclWriteEnabled(const bool val) { + this->exclWriteEnabled = val; +__isset.exclWriteEnabled = true; +} + +void CommitTxnRequest::__set_txn_type(const TxnType::type val) { + this->txn_type = val; +__isset.txn_type = true; +} +std::ostream& operator<<(std::ostream& out, const CommitTxnRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t CommitTxnRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_txnid = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnid); + isset_txnid = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->replPolicy); + this->__isset.replPolicy = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->writeEventInfos.clear(); + uint32_t _size898; + ::apache::thrift::protocol::TType _etype901; + xfer += iprot->readListBegin(_etype901, _size898); + this->writeEventInfos.resize(_size898); + uint32_t _i902; + for (_i902 = 0; _i902 < _size898; ++_i902) + { + xfer += this->writeEventInfos[_i902].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.writeEventInfos = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->replLastIdInfo.read(iprot); + this->__isset.replLastIdInfo = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->keyValue.read(iprot); + this->__isset.keyValue = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->exclWriteEnabled); + this->__isset.exclWriteEnabled = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast903; + xfer += iprot->readI32(ecast903); + this->txn_type = static_cast(ecast903); + this->__isset.txn_type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_txnid) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t CommitTxnRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CommitTxnRequest"); + + xfer += oprot->writeFieldBegin("txnid", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->txnid); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.replPolicy) { + xfer += oprot->writeFieldBegin("replPolicy", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->replPolicy); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.writeEventInfos) { + xfer += oprot->writeFieldBegin("writeEventInfos", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->writeEventInfos.size())); + std::vector ::const_iterator _iter904; + for (_iter904 = this->writeEventInfos.begin(); _iter904 != this->writeEventInfos.end(); ++_iter904) + { + xfer += (*_iter904).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.replLastIdInfo) { + xfer += oprot->writeFieldBegin("replLastIdInfo", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->replLastIdInfo.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.keyValue) { + xfer += oprot->writeFieldBegin("keyValue", ::apache::thrift::protocol::T_STRUCT, 5); + xfer += this->keyValue.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.exclWriteEnabled) { + xfer += oprot->writeFieldBegin("exclWriteEnabled", ::apache::thrift::protocol::T_BOOL, 6); + xfer += oprot->writeBool(this->exclWriteEnabled); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.txn_type) { + xfer += oprot->writeFieldBegin("txn_type", ::apache::thrift::protocol::T_I32, 7); + xfer += oprot->writeI32(static_cast(this->txn_type)); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CommitTxnRequest &a, CommitTxnRequest &b) noexcept { + using ::std::swap; + swap(a.txnid, b.txnid); + swap(a.replPolicy, b.replPolicy); + swap(a.writeEventInfos, b.writeEventInfos); + swap(a.replLastIdInfo, b.replLastIdInfo); + swap(a.keyValue, b.keyValue); + swap(a.exclWriteEnabled, b.exclWriteEnabled); + swap(a.txn_type, b.txn_type); + swap(a.__isset, b.__isset); +} + +bool CommitTxnRequest::operator==(const CommitTxnRequest & rhs) const +{ + if (!(txnid == rhs.txnid)) + return false; + if (__isset.replPolicy != rhs.__isset.replPolicy) + return false; + else if (__isset.replPolicy && !(replPolicy == rhs.replPolicy)) + return false; + if (__isset.writeEventInfos != rhs.__isset.writeEventInfos) + return false; + else if (__isset.writeEventInfos && !(writeEventInfos == rhs.writeEventInfos)) + return false; + if (__isset.replLastIdInfo != rhs.__isset.replLastIdInfo) + return false; + else if (__isset.replLastIdInfo && !(replLastIdInfo == rhs.replLastIdInfo)) + return false; + if (__isset.keyValue != rhs.__isset.keyValue) + return false; + else if (__isset.keyValue && !(keyValue == rhs.keyValue)) + return false; + if (__isset.exclWriteEnabled != rhs.__isset.exclWriteEnabled) + return false; + else if (__isset.exclWriteEnabled && !(exclWriteEnabled == rhs.exclWriteEnabled)) + return false; + if (__isset.txn_type != rhs.__isset.txn_type) + return false; + else if (__isset.txn_type && !(txn_type == rhs.txn_type)) + return false; + return true; +} + +CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other905) { + txnid = other905.txnid; + replPolicy = other905.replPolicy; + writeEventInfos = other905.writeEventInfos; + replLastIdInfo = other905.replLastIdInfo; + keyValue = other905.keyValue; + exclWriteEnabled = other905.exclWriteEnabled; + txn_type = other905.txn_type; + __isset = other905.__isset; +} +CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other906) { + txnid = other906.txnid; + replPolicy = other906.replPolicy; + writeEventInfos = other906.writeEventInfos; + replLastIdInfo = other906.replLastIdInfo; + keyValue = other906.keyValue; + exclWriteEnabled = other906.exclWriteEnabled; + txn_type = other906.txn_type; + __isset = other906.__isset; + return *this; +} +void CommitTxnRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CommitTxnRequest("; + out << "txnid=" << to_string(txnid); + out << ", " << "replPolicy="; (__isset.replPolicy ? (out << to_string(replPolicy)) : (out << "")); + out << ", " << "writeEventInfos="; (__isset.writeEventInfos ? (out << to_string(writeEventInfos)) : (out << "")); + out << ", " << "replLastIdInfo="; (__isset.replLastIdInfo ? (out << to_string(replLastIdInfo)) : (out << "")); + out << ", " << "keyValue="; (__isset.keyValue ? (out << to_string(keyValue)) : (out << "")); + out << ", " << "exclWriteEnabled="; (__isset.exclWriteEnabled ? (out << to_string(exclWriteEnabled)) : (out << "")); + out << ", " << "txn_type="; (__isset.txn_type ? (out << to_string(txn_type)) : (out << "")); + out << ")"; +} + + +ReplTblWriteIdStateRequest::~ReplTblWriteIdStateRequest() noexcept { +} + +ReplTblWriteIdStateRequest::ReplTblWriteIdStateRequest() noexcept + : validWriteIdlist(), + user(), + hostName(), + dbName(), + tableName() { +} + +void ReplTblWriteIdStateRequest::__set_validWriteIdlist(const std::string& val) { + this->validWriteIdlist = val; +} + +void ReplTblWriteIdStateRequest::__set_user(const std::string& val) { + this->user = val; +} + +void ReplTblWriteIdStateRequest::__set_hostName(const std::string& val) { + this->hostName = val; +} + +void ReplTblWriteIdStateRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void ReplTblWriteIdStateRequest::__set_tableName(const std::string& val) { + this->tableName = val; +} + +void ReplTblWriteIdStateRequest::__set_partNames(const std::vector & val) { + this->partNames = val; +__isset.partNames = true; +} +std::ostream& operator<<(std::ostream& out, const ReplTblWriteIdStateRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ReplTblWriteIdStateRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_validWriteIdlist = false; + bool isset_user = false; + bool isset_hostName = false; + bool isset_dbName = false; + bool isset_tableName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdlist); + isset_validWriteIdlist = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->user); + isset_user = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->hostName); + isset_hostName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + isset_tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partNames.clear(); + uint32_t _size907; + ::apache::thrift::protocol::TType _etype910; + xfer += iprot->readListBegin(_etype910, _size907); + this->partNames.resize(_size907); + uint32_t _i911; + for (_i911 = 0; _i911 < _size907; ++_i911) + { + xfer += iprot->readString(this->partNames[_i911]); + } + xfer += iprot->readListEnd(); + } + this->__isset.partNames = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_validWriteIdlist) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_user) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_hostName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tableName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ReplTblWriteIdStateRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ReplTblWriteIdStateRequest"); + + xfer += oprot->writeFieldBegin("validWriteIdlist", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->validWriteIdlist); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("user", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->user); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("hostName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->hostName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.partNames) { + xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 6); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partNames.size())); + std::vector ::const_iterator _iter912; + for (_iter912 = this->partNames.begin(); _iter912 != this->partNames.end(); ++_iter912) + { + xfer += oprot->writeString((*_iter912)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ReplTblWriteIdStateRequest &a, ReplTblWriteIdStateRequest &b) noexcept { + using ::std::swap; + swap(a.validWriteIdlist, b.validWriteIdlist); + swap(a.user, b.user); + swap(a.hostName, b.hostName); + swap(a.dbName, b.dbName); + swap(a.tableName, b.tableName); + swap(a.partNames, b.partNames); + swap(a.__isset, b.__isset); +} + +bool ReplTblWriteIdStateRequest::operator==(const ReplTblWriteIdStateRequest & rhs) const +{ + if (!(validWriteIdlist == rhs.validWriteIdlist)) + return false; + if (!(user == rhs.user)) + return false; + if (!(hostName == rhs.hostName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (__isset.partNames != rhs.__isset.partNames) + return false; + else if (__isset.partNames && !(partNames == rhs.partNames)) + return false; + return true; +} + +ReplTblWriteIdStateRequest::ReplTblWriteIdStateRequest(const ReplTblWriteIdStateRequest& other913) { + validWriteIdlist = other913.validWriteIdlist; + user = other913.user; + hostName = other913.hostName; + dbName = other913.dbName; + tableName = other913.tableName; + partNames = other913.partNames; + __isset = other913.__isset; +} +ReplTblWriteIdStateRequest& ReplTblWriteIdStateRequest::operator=(const ReplTblWriteIdStateRequest& other914) { + validWriteIdlist = other914.validWriteIdlist; + user = other914.user; + hostName = other914.hostName; + dbName = other914.dbName; + tableName = other914.tableName; + partNames = other914.partNames; + __isset = other914.__isset; + return *this; +} +void ReplTblWriteIdStateRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ReplTblWriteIdStateRequest("; + out << "validWriteIdlist=" << to_string(validWriteIdlist); + out << ", " << "user=" << to_string(user); + out << ", " << "hostName=" << to_string(hostName); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "tableName=" << to_string(tableName); + out << ", " << "partNames="; (__isset.partNames ? (out << to_string(partNames)) : (out << "")); + out << ")"; +} + + +GetValidWriteIdsRequest::~GetValidWriteIdsRequest() noexcept { +} + +GetValidWriteIdsRequest::GetValidWriteIdsRequest() noexcept + : validTxnList(), + writeId(0) { +} + +void GetValidWriteIdsRequest::__set_fullTableNames(const std::vector & val) { + this->fullTableNames = val; +} + +void GetValidWriteIdsRequest::__set_validTxnList(const std::string& val) { + this->validTxnList = val; +__isset.validTxnList = true; +} + +void GetValidWriteIdsRequest::__set_writeId(const int64_t val) { + this->writeId = val; +__isset.writeId = true; +} +std::ostream& operator<<(std::ostream& out, const GetValidWriteIdsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetValidWriteIdsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_fullTableNames = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->fullTableNames.clear(); + uint32_t _size915; + ::apache::thrift::protocol::TType _etype918; + xfer += iprot->readListBegin(_etype918, _size915); + this->fullTableNames.resize(_size915); + uint32_t _i919; + for (_i919 = 0; _i919 < _size915; ++_i919) + { + xfer += iprot->readString(this->fullTableNames[_i919]); + } + xfer += iprot->readListEnd(); + } + isset_fullTableNames = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validTxnList); + this->__isset.validTxnList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->writeId); + this->__isset.writeId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_fullTableNames) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetValidWriteIdsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetValidWriteIdsRequest"); + + xfer += oprot->writeFieldBegin("fullTableNames", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->fullTableNames.size())); + std::vector ::const_iterator _iter920; + for (_iter920 = this->fullTableNames.begin(); _iter920 != this->fullTableNames.end(); ++_iter920) + { + xfer += oprot->writeString((*_iter920)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.validTxnList) { + xfer += oprot->writeFieldBegin("validTxnList", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->validTxnList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.writeId) { + xfer += oprot->writeFieldBegin("writeId", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->writeId); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetValidWriteIdsRequest &a, GetValidWriteIdsRequest &b) noexcept { + using ::std::swap; + swap(a.fullTableNames, b.fullTableNames); + swap(a.validTxnList, b.validTxnList); + swap(a.writeId, b.writeId); + swap(a.__isset, b.__isset); +} + +bool GetValidWriteIdsRequest::operator==(const GetValidWriteIdsRequest & rhs) const +{ + if (!(fullTableNames == rhs.fullTableNames)) + return false; + if (__isset.validTxnList != rhs.__isset.validTxnList) + return false; + else if (__isset.validTxnList && !(validTxnList == rhs.validTxnList)) + return false; + if (__isset.writeId != rhs.__isset.writeId) + return false; + else if (__isset.writeId && !(writeId == rhs.writeId)) + return false; + return true; +} + +GetValidWriteIdsRequest::GetValidWriteIdsRequest(const GetValidWriteIdsRequest& other921) { + fullTableNames = other921.fullTableNames; + validTxnList = other921.validTxnList; + writeId = other921.writeId; + __isset = other921.__isset; +} +GetValidWriteIdsRequest& GetValidWriteIdsRequest::operator=(const GetValidWriteIdsRequest& other922) { + fullTableNames = other922.fullTableNames; + validTxnList = other922.validTxnList; + writeId = other922.writeId; + __isset = other922.__isset; + return *this; +} +void GetValidWriteIdsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetValidWriteIdsRequest("; + out << "fullTableNames=" << to_string(fullTableNames); + out << ", " << "validTxnList="; (__isset.validTxnList ? (out << to_string(validTxnList)) : (out << "")); + out << ", " << "writeId="; (__isset.writeId ? (out << to_string(writeId)) : (out << "")); + out << ")"; +} + + +TableValidWriteIds::~TableValidWriteIds() noexcept { +} + +TableValidWriteIds::TableValidWriteIds() noexcept + : fullTableName(), + writeIdHighWaterMark(0), + minOpenWriteId(0), + abortedBits() { +} + +void TableValidWriteIds::__set_fullTableName(const std::string& val) { + this->fullTableName = val; +} + +void TableValidWriteIds::__set_writeIdHighWaterMark(const int64_t val) { + this->writeIdHighWaterMark = val; +} + +void TableValidWriteIds::__set_invalidWriteIds(const std::vector & val) { + this->invalidWriteIds = val; +} + +void TableValidWriteIds::__set_minOpenWriteId(const int64_t val) { + this->minOpenWriteId = val; +__isset.minOpenWriteId = true; +} + +void TableValidWriteIds::__set_abortedBits(const std::string& val) { + this->abortedBits = val; +} +std::ostream& operator<<(std::ostream& out, const TableValidWriteIds& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t TableValidWriteIds::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_fullTableName = false; + bool isset_writeIdHighWaterMark = false; + bool isset_invalidWriteIds = false; + bool isset_abortedBits = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->fullTableName); + isset_fullTableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->writeIdHighWaterMark); + isset_writeIdHighWaterMark = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->invalidWriteIds.clear(); + uint32_t _size923; + ::apache::thrift::protocol::TType _etype926; + xfer += iprot->readListBegin(_etype926, _size923); + this->invalidWriteIds.resize(_size923); + uint32_t _i927; + for (_i927 = 0; _i927 < _size923; ++_i927) + { + xfer += iprot->readI64(this->invalidWriteIds[_i927]); + } + xfer += iprot->readListEnd(); + } + isset_invalidWriteIds = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->minOpenWriteId); + this->__isset.minOpenWriteId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->abortedBits); + isset_abortedBits = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_fullTableName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_writeIdHighWaterMark) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_invalidWriteIds) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_abortedBits) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t TableValidWriteIds::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("TableValidWriteIds"); + + xfer += oprot->writeFieldBegin("fullTableName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->fullTableName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("writeIdHighWaterMark", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->writeIdHighWaterMark); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("invalidWriteIds", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->invalidWriteIds.size())); + std::vector ::const_iterator _iter928; + for (_iter928 = this->invalidWriteIds.begin(); _iter928 != this->invalidWriteIds.end(); ++_iter928) + { + xfer += oprot->writeI64((*_iter928)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.minOpenWriteId) { + xfer += oprot->writeFieldBegin("minOpenWriteId", ::apache::thrift::protocol::T_I64, 4); + xfer += oprot->writeI64(this->minOpenWriteId); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("abortedBits", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeBinary(this->abortedBits); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(TableValidWriteIds &a, TableValidWriteIds &b) noexcept { + using ::std::swap; + swap(a.fullTableName, b.fullTableName); + swap(a.writeIdHighWaterMark, b.writeIdHighWaterMark); + swap(a.invalidWriteIds, b.invalidWriteIds); + swap(a.minOpenWriteId, b.minOpenWriteId); + swap(a.abortedBits, b.abortedBits); + swap(a.__isset, b.__isset); +} + +bool TableValidWriteIds::operator==(const TableValidWriteIds & rhs) const +{ + if (!(fullTableName == rhs.fullTableName)) + return false; + if (!(writeIdHighWaterMark == rhs.writeIdHighWaterMark)) + return false; + if (!(invalidWriteIds == rhs.invalidWriteIds)) + return false; + if (__isset.minOpenWriteId != rhs.__isset.minOpenWriteId) + return false; + else if (__isset.minOpenWriteId && !(minOpenWriteId == rhs.minOpenWriteId)) + return false; + if (!(abortedBits == rhs.abortedBits)) + return false; + return true; +} + +TableValidWriteIds::TableValidWriteIds(const TableValidWriteIds& other929) { + fullTableName = other929.fullTableName; + writeIdHighWaterMark = other929.writeIdHighWaterMark; + invalidWriteIds = other929.invalidWriteIds; + minOpenWriteId = other929.minOpenWriteId; + abortedBits = other929.abortedBits; + __isset = other929.__isset; +} +TableValidWriteIds& TableValidWriteIds::operator=(const TableValidWriteIds& other930) { + fullTableName = other930.fullTableName; + writeIdHighWaterMark = other930.writeIdHighWaterMark; + invalidWriteIds = other930.invalidWriteIds; + minOpenWriteId = other930.minOpenWriteId; + abortedBits = other930.abortedBits; + __isset = other930.__isset; + return *this; +} +void TableValidWriteIds::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "TableValidWriteIds("; + out << "fullTableName=" << to_string(fullTableName); + out << ", " << "writeIdHighWaterMark=" << to_string(writeIdHighWaterMark); + out << ", " << "invalidWriteIds=" << to_string(invalidWriteIds); + out << ", " << "minOpenWriteId="; (__isset.minOpenWriteId ? (out << to_string(minOpenWriteId)) : (out << "")); + out << ", " << "abortedBits=" << to_string(abortedBits); + out << ")"; +} + + +GetValidWriteIdsResponse::~GetValidWriteIdsResponse() noexcept { +} + +GetValidWriteIdsResponse::GetValidWriteIdsResponse() noexcept { +} + +void GetValidWriteIdsResponse::__set_tblValidWriteIds(const std::vector & val) { + this->tblValidWriteIds = val; +} +std::ostream& operator<<(std::ostream& out, const GetValidWriteIdsResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetValidWriteIdsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_tblValidWriteIds = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->tblValidWriteIds.clear(); + uint32_t _size931; + ::apache::thrift::protocol::TType _etype934; + xfer += iprot->readListBegin(_etype934, _size931); + this->tblValidWriteIds.resize(_size931); + uint32_t _i935; + for (_i935 = 0; _i935 < _size931; ++_i935) + { + xfer += this->tblValidWriteIds[_i935].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_tblValidWriteIds = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_tblValidWriteIds) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetValidWriteIdsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetValidWriteIdsResponse"); + + xfer += oprot->writeFieldBegin("tblValidWriteIds", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->tblValidWriteIds.size())); + std::vector ::const_iterator _iter936; + for (_iter936 = this->tblValidWriteIds.begin(); _iter936 != this->tblValidWriteIds.end(); ++_iter936) + { + xfer += (*_iter936).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetValidWriteIdsResponse &a, GetValidWriteIdsResponse &b) noexcept { + using ::std::swap; + swap(a.tblValidWriteIds, b.tblValidWriteIds); +} + +bool GetValidWriteIdsResponse::operator==(const GetValidWriteIdsResponse & rhs) const +{ + if (!(tblValidWriteIds == rhs.tblValidWriteIds)) + return false; + return true; +} + +GetValidWriteIdsResponse::GetValidWriteIdsResponse(const GetValidWriteIdsResponse& other937) { + tblValidWriteIds = other937.tblValidWriteIds; +} +GetValidWriteIdsResponse& GetValidWriteIdsResponse::operator=(const GetValidWriteIdsResponse& other938) { + tblValidWriteIds = other938.tblValidWriteIds; + return *this; +} +void GetValidWriteIdsResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetValidWriteIdsResponse("; + out << "tblValidWriteIds=" << to_string(tblValidWriteIds); + out << ")"; +} + + +TxnToWriteId::~TxnToWriteId() noexcept { +} + +TxnToWriteId::TxnToWriteId() noexcept + : txnId(0), + writeId(0) { +} + +void TxnToWriteId::__set_txnId(const int64_t val) { + this->txnId = val; +} + +void TxnToWriteId::__set_writeId(const int64_t val) { + this->writeId = val; +} +std::ostream& operator<<(std::ostream& out, const TxnToWriteId& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t TxnToWriteId::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_txnId = false; + bool isset_writeId = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnId); + isset_txnId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->writeId); + isset_writeId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_txnId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_writeId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t TxnToWriteId::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("TxnToWriteId"); + + xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->txnId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("writeId", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->writeId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(TxnToWriteId &a, TxnToWriteId &b) noexcept { + using ::std::swap; + swap(a.txnId, b.txnId); + swap(a.writeId, b.writeId); +} + +bool TxnToWriteId::operator==(const TxnToWriteId & rhs) const +{ + if (!(txnId == rhs.txnId)) + return false; + if (!(writeId == rhs.writeId)) + return false; + return true; +} + +TxnToWriteId::TxnToWriteId(const TxnToWriteId& other939) noexcept { + txnId = other939.txnId; + writeId = other939.writeId; +} +TxnToWriteId& TxnToWriteId::operator=(const TxnToWriteId& other940) noexcept { + txnId = other940.txnId; + writeId = other940.writeId; + return *this; +} +void TxnToWriteId::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "TxnToWriteId("; + out << "txnId=" << to_string(txnId); + out << ", " << "writeId=" << to_string(writeId); + out << ")"; +} + + +AllocateTableWriteIdsRequest::~AllocateTableWriteIdsRequest() noexcept { +} + +AllocateTableWriteIdsRequest::AllocateTableWriteIdsRequest() noexcept + : dbName(), + tableName(), + replPolicy(), + reallocate(false) { +} + +void AllocateTableWriteIdsRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void AllocateTableWriteIdsRequest::__set_tableName(const std::string& val) { + this->tableName = val; +} + +void AllocateTableWriteIdsRequest::__set_txnIds(const std::vector & val) { + this->txnIds = val; +__isset.txnIds = true; +} + +void AllocateTableWriteIdsRequest::__set_replPolicy(const std::string& val) { + this->replPolicy = val; +__isset.replPolicy = true; +} + +void AllocateTableWriteIdsRequest::__set_srcTxnToWriteIdList(const std::vector & val) { + this->srcTxnToWriteIdList = val; +__isset.srcTxnToWriteIdList = true; +} + +void AllocateTableWriteIdsRequest::__set_reallocate(const bool val) { + this->reallocate = val; +__isset.reallocate = true; +} +std::ostream& operator<<(std::ostream& out, const AllocateTableWriteIdsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AllocateTableWriteIdsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tableName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + isset_tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->txnIds.clear(); + uint32_t _size941; + ::apache::thrift::protocol::TType _etype944; + xfer += iprot->readListBegin(_etype944, _size941); + this->txnIds.resize(_size941); + uint32_t _i945; + for (_i945 = 0; _i945 < _size941; ++_i945) + { + xfer += iprot->readI64(this->txnIds[_i945]); + } + xfer += iprot->readListEnd(); + } + this->__isset.txnIds = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->replPolicy); + this->__isset.replPolicy = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->srcTxnToWriteIdList.clear(); + uint32_t _size946; + ::apache::thrift::protocol::TType _etype949; + xfer += iprot->readListBegin(_etype949, _size946); + this->srcTxnToWriteIdList.resize(_size946); + uint32_t _i950; + for (_i950 = 0; _i950 < _size946; ++_i950) + { + xfer += this->srcTxnToWriteIdList[_i950].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.srcTxnToWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->reallocate); + this->__isset.reallocate = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tableName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AllocateTableWriteIdsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AllocateTableWriteIdsRequest"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.txnIds) { + xfer += oprot->writeFieldBegin("txnIds", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->txnIds.size())); + std::vector ::const_iterator _iter951; + for (_iter951 = this->txnIds.begin(); _iter951 != this->txnIds.end(); ++_iter951) + { + xfer += oprot->writeI64((*_iter951)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.replPolicy) { + xfer += oprot->writeFieldBegin("replPolicy", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->replPolicy); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.srcTxnToWriteIdList) { + xfer += oprot->writeFieldBegin("srcTxnToWriteIdList", ::apache::thrift::protocol::T_LIST, 5); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->srcTxnToWriteIdList.size())); + std::vector ::const_iterator _iter952; + for (_iter952 = this->srcTxnToWriteIdList.begin(); _iter952 != this->srcTxnToWriteIdList.end(); ++_iter952) + { + xfer += (*_iter952).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.reallocate) { + xfer += oprot->writeFieldBegin("reallocate", ::apache::thrift::protocol::T_BOOL, 6); + xfer += oprot->writeBool(this->reallocate); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AllocateTableWriteIdsRequest &a, AllocateTableWriteIdsRequest &b) noexcept { + using ::std::swap; + swap(a.dbName, b.dbName); + swap(a.tableName, b.tableName); + swap(a.txnIds, b.txnIds); + swap(a.replPolicy, b.replPolicy); + swap(a.srcTxnToWriteIdList, b.srcTxnToWriteIdList); + swap(a.reallocate, b.reallocate); + swap(a.__isset, b.__isset); +} + +bool AllocateTableWriteIdsRequest::operator==(const AllocateTableWriteIdsRequest & rhs) const +{ + if (!(dbName == rhs.dbName)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (__isset.txnIds != rhs.__isset.txnIds) + return false; + else if (__isset.txnIds && !(txnIds == rhs.txnIds)) + return false; + if (__isset.replPolicy != rhs.__isset.replPolicy) + return false; + else if (__isset.replPolicy && !(replPolicy == rhs.replPolicy)) + return false; + if (__isset.srcTxnToWriteIdList != rhs.__isset.srcTxnToWriteIdList) + return false; + else if (__isset.srcTxnToWriteIdList && !(srcTxnToWriteIdList == rhs.srcTxnToWriteIdList)) + return false; + if (__isset.reallocate != rhs.__isset.reallocate) + return false; + else if (__isset.reallocate && !(reallocate == rhs.reallocate)) + return false; + return true; +} + +AllocateTableWriteIdsRequest::AllocateTableWriteIdsRequest(const AllocateTableWriteIdsRequest& other953) { + dbName = other953.dbName; + tableName = other953.tableName; + txnIds = other953.txnIds; + replPolicy = other953.replPolicy; + srcTxnToWriteIdList = other953.srcTxnToWriteIdList; + reallocate = other953.reallocate; + __isset = other953.__isset; +} +AllocateTableWriteIdsRequest& AllocateTableWriteIdsRequest::operator=(const AllocateTableWriteIdsRequest& other954) { + dbName = other954.dbName; + tableName = other954.tableName; + txnIds = other954.txnIds; + replPolicy = other954.replPolicy; + srcTxnToWriteIdList = other954.srcTxnToWriteIdList; + reallocate = other954.reallocate; + __isset = other954.__isset; + return *this; +} +void AllocateTableWriteIdsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AllocateTableWriteIdsRequest("; + out << "dbName=" << to_string(dbName); + out << ", " << "tableName=" << to_string(tableName); + out << ", " << "txnIds="; (__isset.txnIds ? (out << to_string(txnIds)) : (out << "")); + out << ", " << "replPolicy="; (__isset.replPolicy ? (out << to_string(replPolicy)) : (out << "")); + out << ", " << "srcTxnToWriteIdList="; (__isset.srcTxnToWriteIdList ? (out << to_string(srcTxnToWriteIdList)) : (out << "")); + out << ", " << "reallocate="; (__isset.reallocate ? (out << to_string(reallocate)) : (out << "")); + out << ")"; +} + + +AllocateTableWriteIdsResponse::~AllocateTableWriteIdsResponse() noexcept { +} + +AllocateTableWriteIdsResponse::AllocateTableWriteIdsResponse() noexcept { +} + +void AllocateTableWriteIdsResponse::__set_txnToWriteIds(const std::vector & val) { + this->txnToWriteIds = val; +} +std::ostream& operator<<(std::ostream& out, const AllocateTableWriteIdsResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AllocateTableWriteIdsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_txnToWriteIds = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->txnToWriteIds.clear(); + uint32_t _size955; + ::apache::thrift::protocol::TType _etype958; + xfer += iprot->readListBegin(_etype958, _size955); + this->txnToWriteIds.resize(_size955); + uint32_t _i959; + for (_i959 = 0; _i959 < _size955; ++_i959) + { + xfer += this->txnToWriteIds[_i959].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_txnToWriteIds = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_txnToWriteIds) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AllocateTableWriteIdsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AllocateTableWriteIdsResponse"); + + xfer += oprot->writeFieldBegin("txnToWriteIds", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->txnToWriteIds.size())); + std::vector ::const_iterator _iter960; + for (_iter960 = this->txnToWriteIds.begin(); _iter960 != this->txnToWriteIds.end(); ++_iter960) + { + xfer += (*_iter960).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AllocateTableWriteIdsResponse &a, AllocateTableWriteIdsResponse &b) noexcept { + using ::std::swap; + swap(a.txnToWriteIds, b.txnToWriteIds); +} + +bool AllocateTableWriteIdsResponse::operator==(const AllocateTableWriteIdsResponse & rhs) const +{ + if (!(txnToWriteIds == rhs.txnToWriteIds)) + return false; + return true; +} + +AllocateTableWriteIdsResponse::AllocateTableWriteIdsResponse(const AllocateTableWriteIdsResponse& other961) { + txnToWriteIds = other961.txnToWriteIds; +} +AllocateTableWriteIdsResponse& AllocateTableWriteIdsResponse::operator=(const AllocateTableWriteIdsResponse& other962) { + txnToWriteIds = other962.txnToWriteIds; + return *this; +} +void AllocateTableWriteIdsResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AllocateTableWriteIdsResponse("; + out << "txnToWriteIds=" << to_string(txnToWriteIds); + out << ")"; +} + + +MaxAllocatedTableWriteIdRequest::~MaxAllocatedTableWriteIdRequest() noexcept { +} + +MaxAllocatedTableWriteIdRequest::MaxAllocatedTableWriteIdRequest() noexcept + : dbName(), + tableName() { +} + +void MaxAllocatedTableWriteIdRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void MaxAllocatedTableWriteIdRequest::__set_tableName(const std::string& val) { + this->tableName = val; +} +std::ostream& operator<<(std::ostream& out, const MaxAllocatedTableWriteIdRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t MaxAllocatedTableWriteIdRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tableName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + isset_tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tableName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t MaxAllocatedTableWriteIdRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("MaxAllocatedTableWriteIdRequest"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(MaxAllocatedTableWriteIdRequest &a, MaxAllocatedTableWriteIdRequest &b) noexcept { + using ::std::swap; + swap(a.dbName, b.dbName); + swap(a.tableName, b.tableName); +} + +bool MaxAllocatedTableWriteIdRequest::operator==(const MaxAllocatedTableWriteIdRequest & rhs) const +{ + if (!(dbName == rhs.dbName)) + return false; + if (!(tableName == rhs.tableName)) + return false; + return true; +} + +MaxAllocatedTableWriteIdRequest::MaxAllocatedTableWriteIdRequest(const MaxAllocatedTableWriteIdRequest& other963) { + dbName = other963.dbName; + tableName = other963.tableName; +} +MaxAllocatedTableWriteIdRequest& MaxAllocatedTableWriteIdRequest::operator=(const MaxAllocatedTableWriteIdRequest& other964) { + dbName = other964.dbName; + tableName = other964.tableName; + return *this; +} +void MaxAllocatedTableWriteIdRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "MaxAllocatedTableWriteIdRequest("; + out << "dbName=" << to_string(dbName); + out << ", " << "tableName=" << to_string(tableName); + out << ")"; +} + + +MaxAllocatedTableWriteIdResponse::~MaxAllocatedTableWriteIdResponse() noexcept { +} + +MaxAllocatedTableWriteIdResponse::MaxAllocatedTableWriteIdResponse() noexcept + : maxWriteId(0) { +} + +void MaxAllocatedTableWriteIdResponse::__set_maxWriteId(const int64_t val) { + this->maxWriteId = val; +} +std::ostream& operator<<(std::ostream& out, const MaxAllocatedTableWriteIdResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t MaxAllocatedTableWriteIdResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_maxWriteId = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->maxWriteId); + isset_maxWriteId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_maxWriteId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t MaxAllocatedTableWriteIdResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("MaxAllocatedTableWriteIdResponse"); + + xfer += oprot->writeFieldBegin("maxWriteId", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->maxWriteId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(MaxAllocatedTableWriteIdResponse &a, MaxAllocatedTableWriteIdResponse &b) noexcept { + using ::std::swap; + swap(a.maxWriteId, b.maxWriteId); +} + +bool MaxAllocatedTableWriteIdResponse::operator==(const MaxAllocatedTableWriteIdResponse & rhs) const +{ + if (!(maxWriteId == rhs.maxWriteId)) + return false; + return true; +} + +MaxAllocatedTableWriteIdResponse::MaxAllocatedTableWriteIdResponse(const MaxAllocatedTableWriteIdResponse& other965) noexcept { + maxWriteId = other965.maxWriteId; +} +MaxAllocatedTableWriteIdResponse& MaxAllocatedTableWriteIdResponse::operator=(const MaxAllocatedTableWriteIdResponse& other966) noexcept { + maxWriteId = other966.maxWriteId; + return *this; +} +void MaxAllocatedTableWriteIdResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "MaxAllocatedTableWriteIdResponse("; + out << "maxWriteId=" << to_string(maxWriteId); + out << ")"; +} + + +SeedTableWriteIdsRequest::~SeedTableWriteIdsRequest() noexcept { +} + +SeedTableWriteIdsRequest::SeedTableWriteIdsRequest() noexcept + : dbName(), + tableName(), + seedWriteId(0) { +} + +void SeedTableWriteIdsRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void SeedTableWriteIdsRequest::__set_tableName(const std::string& val) { + this->tableName = val; +} + +void SeedTableWriteIdsRequest::__set_seedWriteId(const int64_t val) { + this->seedWriteId = val; +} +std::ostream& operator<<(std::ostream& out, const SeedTableWriteIdsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t SeedTableWriteIdsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tableName = false; + bool isset_seedWriteId = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + isset_tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->seedWriteId); + isset_seedWriteId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tableName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_seedWriteId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t SeedTableWriteIdsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("SeedTableWriteIdsRequest"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("seedWriteId", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->seedWriteId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(SeedTableWriteIdsRequest &a, SeedTableWriteIdsRequest &b) noexcept { + using ::std::swap; + swap(a.dbName, b.dbName); + swap(a.tableName, b.tableName); + swap(a.seedWriteId, b.seedWriteId); +} + +bool SeedTableWriteIdsRequest::operator==(const SeedTableWriteIdsRequest & rhs) const +{ + if (!(dbName == rhs.dbName)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(seedWriteId == rhs.seedWriteId)) + return false; + return true; +} + +SeedTableWriteIdsRequest::SeedTableWriteIdsRequest(const SeedTableWriteIdsRequest& other967) { + dbName = other967.dbName; + tableName = other967.tableName; + seedWriteId = other967.seedWriteId; +} +SeedTableWriteIdsRequest& SeedTableWriteIdsRequest::operator=(const SeedTableWriteIdsRequest& other968) { + dbName = other968.dbName; + tableName = other968.tableName; + seedWriteId = other968.seedWriteId; + return *this; +} +void SeedTableWriteIdsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "SeedTableWriteIdsRequest("; + out << "dbName=" << to_string(dbName); + out << ", " << "tableName=" << to_string(tableName); + out << ", " << "seedWriteId=" << to_string(seedWriteId); + out << ")"; +} + + +SeedTxnIdRequest::~SeedTxnIdRequest() noexcept { +} + +SeedTxnIdRequest::SeedTxnIdRequest() noexcept + : seedTxnId(0) { +} + +void SeedTxnIdRequest::__set_seedTxnId(const int64_t val) { + this->seedTxnId = val; +} +std::ostream& operator<<(std::ostream& out, const SeedTxnIdRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t SeedTxnIdRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_seedTxnId = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->seedTxnId); + isset_seedTxnId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_seedTxnId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t SeedTxnIdRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("SeedTxnIdRequest"); + + xfer += oprot->writeFieldBegin("seedTxnId", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->seedTxnId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(SeedTxnIdRequest &a, SeedTxnIdRequest &b) noexcept { + using ::std::swap; + swap(a.seedTxnId, b.seedTxnId); +} + +bool SeedTxnIdRequest::operator==(const SeedTxnIdRequest & rhs) const +{ + if (!(seedTxnId == rhs.seedTxnId)) + return false; + return true; +} + +SeedTxnIdRequest::SeedTxnIdRequest(const SeedTxnIdRequest& other969) noexcept { + seedTxnId = other969.seedTxnId; +} +SeedTxnIdRequest& SeedTxnIdRequest::operator=(const SeedTxnIdRequest& other970) noexcept { + seedTxnId = other970.seedTxnId; + return *this; +} +void SeedTxnIdRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "SeedTxnIdRequest("; + out << "seedTxnId=" << to_string(seedTxnId); + out << ")"; +} + + +LockComponent::~LockComponent() noexcept { +} + +LockComponent::LockComponent() noexcept + : type(static_cast(0)), + level(static_cast(0)), + dbname(), + tablename(), + partitionname(), + operationType(static_cast(5)), + isTransactional(false), + isDynamicPartitionWrite(false) { +} + +void LockComponent::__set_type(const LockType::type val) { + this->type = val; +} + +void LockComponent::__set_level(const LockLevel::type val) { + this->level = val; +} + +void LockComponent::__set_dbname(const std::string& val) { + this->dbname = val; +} + +void LockComponent::__set_tablename(const std::string& val) { + this->tablename = val; +__isset.tablename = true; +} + +void LockComponent::__set_partitionname(const std::string& val) { + this->partitionname = val; +__isset.partitionname = true; +} + +void LockComponent::__set_operationType(const DataOperationType::type val) { + this->operationType = val; +__isset.operationType = true; +} + +void LockComponent::__set_isTransactional(const bool val) { + this->isTransactional = val; +__isset.isTransactional = true; +} + +void LockComponent::__set_isDynamicPartitionWrite(const bool val) { + this->isDynamicPartitionWrite = val; +__isset.isDynamicPartitionWrite = true; +} +std::ostream& operator<<(std::ostream& out, const LockComponent& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_type = false; + bool isset_level = false; + bool isset_dbname = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast971; + xfer += iprot->readI32(ecast971); + this->type = static_cast(ecast971); + isset_type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast972; + xfer += iprot->readI32(ecast972); + this->level = static_cast(ecast972); + isset_level = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbname); + isset_dbname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tablename); + this->__isset.tablename = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->partitionname); + this->__isset.partitionname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast973; + xfer += iprot->readI32(ecast973); + this->operationType = static_cast(ecast973); + this->__isset.operationType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isTransactional); + this->__isset.isTransactional = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isDynamicPartitionWrite); + this->__isset.isDynamicPartitionWrite = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_type) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_level) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_dbname) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t LockComponent::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("LockComponent"); + + xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32(static_cast(this->type)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("level", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(static_cast(this->level)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->dbname); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.tablename) { + xfer += oprot->writeFieldBegin("tablename", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->tablename); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.partitionname) { + xfer += oprot->writeFieldBegin("partitionname", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->partitionname); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.operationType) { + xfer += oprot->writeFieldBegin("operationType", ::apache::thrift::protocol::T_I32, 6); + xfer += oprot->writeI32(static_cast(this->operationType)); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.isTransactional) { + xfer += oprot->writeFieldBegin("isTransactional", ::apache::thrift::protocol::T_BOOL, 7); + xfer += oprot->writeBool(this->isTransactional); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.isDynamicPartitionWrite) { + xfer += oprot->writeFieldBegin("isDynamicPartitionWrite", ::apache::thrift::protocol::T_BOOL, 8); + xfer += oprot->writeBool(this->isDynamicPartitionWrite); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(LockComponent &a, LockComponent &b) noexcept { + using ::std::swap; + swap(a.type, b.type); + swap(a.level, b.level); + swap(a.dbname, b.dbname); + swap(a.tablename, b.tablename); + swap(a.partitionname, b.partitionname); + swap(a.operationType, b.operationType); + swap(a.isTransactional, b.isTransactional); + swap(a.isDynamicPartitionWrite, b.isDynamicPartitionWrite); + swap(a.__isset, b.__isset); +} + +bool LockComponent::operator==(const LockComponent & rhs) const +{ + if (!(type == rhs.type)) + return false; + if (!(level == rhs.level)) + return false; + if (!(dbname == rhs.dbname)) + return false; + if (__isset.tablename != rhs.__isset.tablename) + return false; + else if (__isset.tablename && !(tablename == rhs.tablename)) + return false; + if (__isset.partitionname != rhs.__isset.partitionname) + return false; + else if (__isset.partitionname && !(partitionname == rhs.partitionname)) + return false; + if (__isset.operationType != rhs.__isset.operationType) + return false; + else if (__isset.operationType && !(operationType == rhs.operationType)) + return false; + if (__isset.isTransactional != rhs.__isset.isTransactional) + return false; + else if (__isset.isTransactional && !(isTransactional == rhs.isTransactional)) + return false; + if (__isset.isDynamicPartitionWrite != rhs.__isset.isDynamicPartitionWrite) + return false; + else if (__isset.isDynamicPartitionWrite && !(isDynamicPartitionWrite == rhs.isDynamicPartitionWrite)) + return false; + return true; +} + +LockComponent::LockComponent(const LockComponent& other974) { + type = other974.type; + level = other974.level; + dbname = other974.dbname; + tablename = other974.tablename; + partitionname = other974.partitionname; + operationType = other974.operationType; + isTransactional = other974.isTransactional; + isDynamicPartitionWrite = other974.isDynamicPartitionWrite; + __isset = other974.__isset; +} +LockComponent& LockComponent::operator=(const LockComponent& other975) { + type = other975.type; + level = other975.level; + dbname = other975.dbname; + tablename = other975.tablename; + partitionname = other975.partitionname; + operationType = other975.operationType; + isTransactional = other975.isTransactional; + isDynamicPartitionWrite = other975.isDynamicPartitionWrite; + __isset = other975.__isset; + return *this; +} +void LockComponent::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "LockComponent("; + out << "type=" << to_string(type); + out << ", " << "level=" << to_string(level); + out << ", " << "dbname=" << to_string(dbname); + out << ", " << "tablename="; (__isset.tablename ? (out << to_string(tablename)) : (out << "")); + out << ", " << "partitionname="; (__isset.partitionname ? (out << to_string(partitionname)) : (out << "")); + out << ", " << "operationType="; (__isset.operationType ? (out << to_string(operationType)) : (out << "")); + out << ", " << "isTransactional="; (__isset.isTransactional ? (out << to_string(isTransactional)) : (out << "")); + out << ", " << "isDynamicPartitionWrite="; (__isset.isDynamicPartitionWrite ? (out << to_string(isDynamicPartitionWrite)) : (out << "")); + out << ")"; +} + + +LockRequest::~LockRequest() noexcept { +} + +LockRequest::LockRequest() : txnid(0), + user(), + hostname(), + agentInfo("Unknown"), + zeroWaitReadEnabled(false), + exclusiveCTAS(false), + locklessReadsEnabled(false) { +} + +void LockRequest::__set_component(const std::vector & val) { + this->component = val; +} + +void LockRequest::__set_txnid(const int64_t val) { + this->txnid = val; +__isset.txnid = true; +} + +void LockRequest::__set_user(const std::string& val) { + this->user = val; +} + +void LockRequest::__set_hostname(const std::string& val) { + this->hostname = val; +} + +void LockRequest::__set_agentInfo(const std::string& val) { + this->agentInfo = val; +__isset.agentInfo = true; +} + +void LockRequest::__set_zeroWaitReadEnabled(const bool val) { + this->zeroWaitReadEnabled = val; +__isset.zeroWaitReadEnabled = true; +} + +void LockRequest::__set_exclusiveCTAS(const bool val) { + this->exclusiveCTAS = val; +__isset.exclusiveCTAS = true; +} + +void LockRequest::__set_locklessReadsEnabled(const bool val) { + this->locklessReadsEnabled = val; +__isset.locklessReadsEnabled = true; +} +std::ostream& operator<<(std::ostream& out, const LockRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t LockRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_component = false; + bool isset_user = false; + bool isset_hostname = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->component.clear(); + uint32_t _size976; + ::apache::thrift::protocol::TType _etype979; + xfer += iprot->readListBegin(_etype979, _size976); + this->component.resize(_size976); + uint32_t _i980; + for (_i980 = 0; _i980 < _size976; ++_i980) + { + xfer += this->component[_i980].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_component = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnid); + this->__isset.txnid = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->user); + isset_user = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->hostname); + isset_hostname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->agentInfo); + this->__isset.agentInfo = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->zeroWaitReadEnabled); + this->__isset.zeroWaitReadEnabled = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->exclusiveCTAS); + this->__isset.exclusiveCTAS = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->locklessReadsEnabled); + this->__isset.locklessReadsEnabled = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_component) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_user) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_hostname) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t LockRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("LockRequest"); + + xfer += oprot->writeFieldBegin("component", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->component.size())); + std::vector ::const_iterator _iter981; + for (_iter981 = this->component.begin(); _iter981 != this->component.end(); ++_iter981) + { + xfer += (*_iter981).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.txnid) { + xfer += oprot->writeFieldBegin("txnid", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->txnid); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("user", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->user); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("hostname", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->hostname); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.agentInfo) { + xfer += oprot->writeFieldBegin("agentInfo", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->agentInfo); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.zeroWaitReadEnabled) { + xfer += oprot->writeFieldBegin("zeroWaitReadEnabled", ::apache::thrift::protocol::T_BOOL, 6); + xfer += oprot->writeBool(this->zeroWaitReadEnabled); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.exclusiveCTAS) { + xfer += oprot->writeFieldBegin("exclusiveCTAS", ::apache::thrift::protocol::T_BOOL, 7); + xfer += oprot->writeBool(this->exclusiveCTAS); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.locklessReadsEnabled) { + xfer += oprot->writeFieldBegin("locklessReadsEnabled", ::apache::thrift::protocol::T_BOOL, 8); + xfer += oprot->writeBool(this->locklessReadsEnabled); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(LockRequest &a, LockRequest &b) noexcept { + using ::std::swap; + swap(a.component, b.component); + swap(a.txnid, b.txnid); + swap(a.user, b.user); + swap(a.hostname, b.hostname); + swap(a.agentInfo, b.agentInfo); + swap(a.zeroWaitReadEnabled, b.zeroWaitReadEnabled); + swap(a.exclusiveCTAS, b.exclusiveCTAS); + swap(a.locklessReadsEnabled, b.locklessReadsEnabled); + swap(a.__isset, b.__isset); +} + +bool LockRequest::operator==(const LockRequest & rhs) const +{ + if (!(component == rhs.component)) + return false; + if (__isset.txnid != rhs.__isset.txnid) + return false; + else if (__isset.txnid && !(txnid == rhs.txnid)) + return false; + if (!(user == rhs.user)) + return false; + if (!(hostname == rhs.hostname)) + return false; + if (__isset.agentInfo != rhs.__isset.agentInfo) + return false; + else if (__isset.agentInfo && !(agentInfo == rhs.agentInfo)) + return false; + if (__isset.zeroWaitReadEnabled != rhs.__isset.zeroWaitReadEnabled) + return false; + else if (__isset.zeroWaitReadEnabled && !(zeroWaitReadEnabled == rhs.zeroWaitReadEnabled)) + return false; + if (__isset.exclusiveCTAS != rhs.__isset.exclusiveCTAS) + return false; + else if (__isset.exclusiveCTAS && !(exclusiveCTAS == rhs.exclusiveCTAS)) + return false; + if (__isset.locklessReadsEnabled != rhs.__isset.locklessReadsEnabled) + return false; + else if (__isset.locklessReadsEnabled && !(locklessReadsEnabled == rhs.locklessReadsEnabled)) + return false; + return true; +} + +LockRequest::LockRequest(const LockRequest& other982) { + component = other982.component; + txnid = other982.txnid; + user = other982.user; + hostname = other982.hostname; + agentInfo = other982.agentInfo; + zeroWaitReadEnabled = other982.zeroWaitReadEnabled; + exclusiveCTAS = other982.exclusiveCTAS; + locklessReadsEnabled = other982.locklessReadsEnabled; + __isset = other982.__isset; +} +LockRequest& LockRequest::operator=(const LockRequest& other983) { + component = other983.component; + txnid = other983.txnid; + user = other983.user; + hostname = other983.hostname; + agentInfo = other983.agentInfo; + zeroWaitReadEnabled = other983.zeroWaitReadEnabled; + exclusiveCTAS = other983.exclusiveCTAS; + locklessReadsEnabled = other983.locklessReadsEnabled; + __isset = other983.__isset; + return *this; +} +void LockRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "LockRequest("; + out << "component=" << to_string(component); + out << ", " << "txnid="; (__isset.txnid ? (out << to_string(txnid)) : (out << "")); + out << ", " << "user=" << to_string(user); + out << ", " << "hostname=" << to_string(hostname); + out << ", " << "agentInfo="; (__isset.agentInfo ? (out << to_string(agentInfo)) : (out << "")); + out << ", " << "zeroWaitReadEnabled="; (__isset.zeroWaitReadEnabled ? (out << to_string(zeroWaitReadEnabled)) : (out << "")); + out << ", " << "exclusiveCTAS="; (__isset.exclusiveCTAS ? (out << to_string(exclusiveCTAS)) : (out << "")); + out << ", " << "locklessReadsEnabled="; (__isset.locklessReadsEnabled ? (out << to_string(locklessReadsEnabled)) : (out << "")); + out << ")"; +} + + +LockResponse::~LockResponse() noexcept { +} + +LockResponse::LockResponse() noexcept + : lockid(0), + state(static_cast(0)), + errorMessage() { +} + +void LockResponse::__set_lockid(const int64_t val) { + this->lockid = val; +} + +void LockResponse::__set_state(const LockState::type val) { + this->state = val; +} + +void LockResponse::__set_errorMessage(const std::string& val) { + this->errorMessage = val; +__isset.errorMessage = true; +} +std::ostream& operator<<(std::ostream& out, const LockResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t LockResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_lockid = false; + bool isset_state = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->lockid); + isset_lockid = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast984; + xfer += iprot->readI32(ecast984); + this->state = static_cast(ecast984); + isset_state = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->errorMessage); + this->__isset.errorMessage = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_lockid) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_state) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t LockResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("LockResponse"); + + xfer += oprot->writeFieldBegin("lockid", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->lockid); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(static_cast(this->state)); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.errorMessage) { + xfer += oprot->writeFieldBegin("errorMessage", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->errorMessage); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(LockResponse &a, LockResponse &b) noexcept { + using ::std::swap; + swap(a.lockid, b.lockid); + swap(a.state, b.state); + swap(a.errorMessage, b.errorMessage); + swap(a.__isset, b.__isset); +} + +bool LockResponse::operator==(const LockResponse & rhs) const +{ + if (!(lockid == rhs.lockid)) + return false; + if (!(state == rhs.state)) + return false; + if (__isset.errorMessage != rhs.__isset.errorMessage) + return false; + else if (__isset.errorMessage && !(errorMessage == rhs.errorMessage)) + return false; + return true; +} + +LockResponse::LockResponse(const LockResponse& other985) { + lockid = other985.lockid; + state = other985.state; + errorMessage = other985.errorMessage; + __isset = other985.__isset; +} +LockResponse& LockResponse::operator=(const LockResponse& other986) { + lockid = other986.lockid; + state = other986.state; + errorMessage = other986.errorMessage; + __isset = other986.__isset; + return *this; +} +void LockResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "LockResponse("; + out << "lockid=" << to_string(lockid); + out << ", " << "state=" << to_string(state); + out << ", " << "errorMessage="; (__isset.errorMessage ? (out << to_string(errorMessage)) : (out << "")); + out << ")"; +} + + +CheckLockRequest::~CheckLockRequest() noexcept { +} + +CheckLockRequest::CheckLockRequest() noexcept + : lockid(0), + txnid(0), + elapsed_ms(0) { +} + +void CheckLockRequest::__set_lockid(const int64_t val) { + this->lockid = val; +} + +void CheckLockRequest::__set_txnid(const int64_t val) { + this->txnid = val; +__isset.txnid = true; +} + +void CheckLockRequest::__set_elapsed_ms(const int64_t val) { + this->elapsed_ms = val; +__isset.elapsed_ms = true; +} +std::ostream& operator<<(std::ostream& out, const CheckLockRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t CheckLockRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_lockid = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->lockid); + isset_lockid = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnid); + this->__isset.txnid = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->elapsed_ms); + this->__isset.elapsed_ms = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_lockid) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t CheckLockRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CheckLockRequest"); + + xfer += oprot->writeFieldBegin("lockid", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->lockid); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.txnid) { + xfer += oprot->writeFieldBegin("txnid", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->txnid); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.elapsed_ms) { + xfer += oprot->writeFieldBegin("elapsed_ms", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->elapsed_ms); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CheckLockRequest &a, CheckLockRequest &b) noexcept { + using ::std::swap; + swap(a.lockid, b.lockid); + swap(a.txnid, b.txnid); + swap(a.elapsed_ms, b.elapsed_ms); + swap(a.__isset, b.__isset); +} + +bool CheckLockRequest::operator==(const CheckLockRequest & rhs) const +{ + if (!(lockid == rhs.lockid)) + return false; + if (__isset.txnid != rhs.__isset.txnid) + return false; + else if (__isset.txnid && !(txnid == rhs.txnid)) + return false; + if (__isset.elapsed_ms != rhs.__isset.elapsed_ms) + return false; + else if (__isset.elapsed_ms && !(elapsed_ms == rhs.elapsed_ms)) + return false; + return true; +} + +CheckLockRequest::CheckLockRequest(const CheckLockRequest& other987) noexcept { + lockid = other987.lockid; + txnid = other987.txnid; + elapsed_ms = other987.elapsed_ms; + __isset = other987.__isset; +} +CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other988) noexcept { + lockid = other988.lockid; + txnid = other988.txnid; + elapsed_ms = other988.elapsed_ms; + __isset = other988.__isset; + return *this; +} +void CheckLockRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CheckLockRequest("; + out << "lockid=" << to_string(lockid); + out << ", " << "txnid="; (__isset.txnid ? (out << to_string(txnid)) : (out << "")); + out << ", " << "elapsed_ms="; (__isset.elapsed_ms ? (out << to_string(elapsed_ms)) : (out << "")); + out << ")"; +} + + +UnlockRequest::~UnlockRequest() noexcept { +} + +UnlockRequest::UnlockRequest() noexcept + : lockid(0) { +} + +void UnlockRequest::__set_lockid(const int64_t val) { + this->lockid = val; +} +std::ostream& operator<<(std::ostream& out, const UnlockRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t UnlockRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_lockid = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->lockid); + isset_lockid = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_lockid) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t UnlockRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("UnlockRequest"); + + xfer += oprot->writeFieldBegin("lockid", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->lockid); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(UnlockRequest &a, UnlockRequest &b) noexcept { + using ::std::swap; + swap(a.lockid, b.lockid); +} + +bool UnlockRequest::operator==(const UnlockRequest & rhs) const +{ + if (!(lockid == rhs.lockid)) + return false; + return true; +} + +UnlockRequest::UnlockRequest(const UnlockRequest& other989) noexcept { + lockid = other989.lockid; +} +UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other990) noexcept { + lockid = other990.lockid; + return *this; +} +void UnlockRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "UnlockRequest("; + out << "lockid=" << to_string(lockid); + out << ")"; +} + + +ShowLocksRequest::~ShowLocksRequest() noexcept { +} + +ShowLocksRequest::ShowLocksRequest() noexcept + : dbname(), + tablename(), + partname(), + isExtended(false), + txnid(0) { +} + +void ShowLocksRequest::__set_dbname(const std::string& val) { + this->dbname = val; +__isset.dbname = true; +} + +void ShowLocksRequest::__set_tablename(const std::string& val) { + this->tablename = val; +__isset.tablename = true; +} + +void ShowLocksRequest::__set_partname(const std::string& val) { + this->partname = val; +__isset.partname = true; +} + +void ShowLocksRequest::__set_isExtended(const bool val) { + this->isExtended = val; +__isset.isExtended = true; +} + +void ShowLocksRequest::__set_txnid(const int64_t val) { + this->txnid = val; +__isset.txnid = true; +} +std::ostream& operator<<(std::ostream& out, const ShowLocksRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ShowLocksRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbname); + this->__isset.dbname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tablename); + this->__isset.tablename = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->partname); + this->__isset.partname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isExtended); + this->__isset.isExtended = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnid); + this->__isset.txnid = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ShowLocksRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ShowLocksRequest"); + + if (this->__isset.dbname) { + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbname); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.tablename) { + xfer += oprot->writeFieldBegin("tablename", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tablename); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.partname) { + xfer += oprot->writeFieldBegin("partname", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->partname); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.isExtended) { + xfer += oprot->writeFieldBegin("isExtended", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool(this->isExtended); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.txnid) { + xfer += oprot->writeFieldBegin("txnid", ::apache::thrift::protocol::T_I64, 5); + xfer += oprot->writeI64(this->txnid); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ShowLocksRequest &a, ShowLocksRequest &b) noexcept { + using ::std::swap; + swap(a.dbname, b.dbname); + swap(a.tablename, b.tablename); + swap(a.partname, b.partname); + swap(a.isExtended, b.isExtended); + swap(a.txnid, b.txnid); + swap(a.__isset, b.__isset); +} + +bool ShowLocksRequest::operator==(const ShowLocksRequest & rhs) const +{ + if (__isset.dbname != rhs.__isset.dbname) + return false; + else if (__isset.dbname && !(dbname == rhs.dbname)) + return false; + if (__isset.tablename != rhs.__isset.tablename) + return false; + else if (__isset.tablename && !(tablename == rhs.tablename)) + return false; + if (__isset.partname != rhs.__isset.partname) + return false; + else if (__isset.partname && !(partname == rhs.partname)) + return false; + if (__isset.isExtended != rhs.__isset.isExtended) + return false; + else if (__isset.isExtended && !(isExtended == rhs.isExtended)) + return false; + if (__isset.txnid != rhs.__isset.txnid) + return false; + else if (__isset.txnid && !(txnid == rhs.txnid)) + return false; + return true; +} + +ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other991) { + dbname = other991.dbname; + tablename = other991.tablename; + partname = other991.partname; + isExtended = other991.isExtended; + txnid = other991.txnid; + __isset = other991.__isset; +} +ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other992) { + dbname = other992.dbname; + tablename = other992.tablename; + partname = other992.partname; + isExtended = other992.isExtended; + txnid = other992.txnid; + __isset = other992.__isset; + return *this; +} +void ShowLocksRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ShowLocksRequest("; + out << "dbname="; (__isset.dbname ? (out << to_string(dbname)) : (out << "")); + out << ", " << "tablename="; (__isset.tablename ? (out << to_string(tablename)) : (out << "")); + out << ", " << "partname="; (__isset.partname ? (out << to_string(partname)) : (out << "")); + out << ", " << "isExtended="; (__isset.isExtended ? (out << to_string(isExtended)) : (out << "")); + out << ", " << "txnid="; (__isset.txnid ? (out << to_string(txnid)) : (out << "")); + out << ")"; +} + + +ShowLocksResponseElement::~ShowLocksResponseElement() noexcept { +} + +ShowLocksResponseElement::ShowLocksResponseElement() noexcept + : lockid(0), + dbname(), + tablename(), + partname(), + state(static_cast(0)), + type(static_cast(0)), + txnid(0), + lastheartbeat(0), + acquiredat(0), + user(), + hostname(), + heartbeatCount(0), + agentInfo(), + blockedByExtId(0), + blockedByIntId(0), + lockIdInternal(0) { +} + +void ShowLocksResponseElement::__set_lockid(const int64_t val) { + this->lockid = val; +} + +void ShowLocksResponseElement::__set_dbname(const std::string& val) { + this->dbname = val; +} + +void ShowLocksResponseElement::__set_tablename(const std::string& val) { + this->tablename = val; +__isset.tablename = true; +} + +void ShowLocksResponseElement::__set_partname(const std::string& val) { + this->partname = val; +__isset.partname = true; +} + +void ShowLocksResponseElement::__set_state(const LockState::type val) { + this->state = val; +} + +void ShowLocksResponseElement::__set_type(const LockType::type val) { + this->type = val; +} + +void ShowLocksResponseElement::__set_txnid(const int64_t val) { + this->txnid = val; +__isset.txnid = true; +} + +void ShowLocksResponseElement::__set_lastheartbeat(const int64_t val) { + this->lastheartbeat = val; +} + +void ShowLocksResponseElement::__set_acquiredat(const int64_t val) { + this->acquiredat = val; +__isset.acquiredat = true; +} + +void ShowLocksResponseElement::__set_user(const std::string& val) { + this->user = val; +} + +void ShowLocksResponseElement::__set_hostname(const std::string& val) { + this->hostname = val; +} + +void ShowLocksResponseElement::__set_heartbeatCount(const int32_t val) { + this->heartbeatCount = val; +__isset.heartbeatCount = true; +} + +void ShowLocksResponseElement::__set_agentInfo(const std::string& val) { + this->agentInfo = val; +__isset.agentInfo = true; +} + +void ShowLocksResponseElement::__set_blockedByExtId(const int64_t val) { + this->blockedByExtId = val; +__isset.blockedByExtId = true; +} + +void ShowLocksResponseElement::__set_blockedByIntId(const int64_t val) { + this->blockedByIntId = val; +__isset.blockedByIntId = true; +} + +void ShowLocksResponseElement::__set_lockIdInternal(const int64_t val) { + this->lockIdInternal = val; +__isset.lockIdInternal = true; +} +std::ostream& operator<<(std::ostream& out, const ShowLocksResponseElement& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_lockid = false; + bool isset_dbname = false; + bool isset_state = false; + bool isset_type = false; + bool isset_lastheartbeat = false; + bool isset_user = false; + bool isset_hostname = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->lockid); + isset_lockid = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbname); + isset_dbname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tablename); + this->__isset.tablename = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->partname); + this->__isset.partname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast993; + xfer += iprot->readI32(ecast993); + this->state = static_cast(ecast993); + isset_state = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast994; + xfer += iprot->readI32(ecast994); + this->type = static_cast(ecast994); + isset_type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnid); + this->__isset.txnid = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->lastheartbeat); + isset_lastheartbeat = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->acquiredat); + this->__isset.acquiredat = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->user); + isset_user = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 11: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->hostname); + isset_hostname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 12: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->heartbeatCount); + this->__isset.heartbeatCount = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 13: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->agentInfo); + this->__isset.agentInfo = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 14: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->blockedByExtId); + this->__isset.blockedByExtId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 15: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->blockedByIntId); + this->__isset.blockedByIntId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 16: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->lockIdInternal); + this->__isset.lockIdInternal = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_lockid) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_dbname) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_state) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_type) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_lastheartbeat) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_user) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_hostname) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ShowLocksResponseElement::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ShowLocksResponseElement"); + + xfer += oprot->writeFieldBegin("lockid", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->lockid); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbname); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.tablename) { + xfer += oprot->writeFieldBegin("tablename", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tablename); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.partname) { + xfer += oprot->writeFieldBegin("partname", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->partname); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_I32, 5); + xfer += oprot->writeI32(static_cast(this->state)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 6); + xfer += oprot->writeI32(static_cast(this->type)); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.txnid) { + xfer += oprot->writeFieldBegin("txnid", ::apache::thrift::protocol::T_I64, 7); + xfer += oprot->writeI64(this->txnid); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("lastheartbeat", ::apache::thrift::protocol::T_I64, 8); + xfer += oprot->writeI64(this->lastheartbeat); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.acquiredat) { + xfer += oprot->writeFieldBegin("acquiredat", ::apache::thrift::protocol::T_I64, 9); + xfer += oprot->writeI64(this->acquiredat); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("user", ::apache::thrift::protocol::T_STRING, 10); + xfer += oprot->writeString(this->user); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("hostname", ::apache::thrift::protocol::T_STRING, 11); + xfer += oprot->writeString(this->hostname); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.heartbeatCount) { + xfer += oprot->writeFieldBegin("heartbeatCount", ::apache::thrift::protocol::T_I32, 12); + xfer += oprot->writeI32(this->heartbeatCount); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.agentInfo) { + xfer += oprot->writeFieldBegin("agentInfo", ::apache::thrift::protocol::T_STRING, 13); + xfer += oprot->writeString(this->agentInfo); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.blockedByExtId) { + xfer += oprot->writeFieldBegin("blockedByExtId", ::apache::thrift::protocol::T_I64, 14); + xfer += oprot->writeI64(this->blockedByExtId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.blockedByIntId) { + xfer += oprot->writeFieldBegin("blockedByIntId", ::apache::thrift::protocol::T_I64, 15); + xfer += oprot->writeI64(this->blockedByIntId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.lockIdInternal) { + xfer += oprot->writeFieldBegin("lockIdInternal", ::apache::thrift::protocol::T_I64, 16); + xfer += oprot->writeI64(this->lockIdInternal); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b) noexcept { + using ::std::swap; + swap(a.lockid, b.lockid); + swap(a.dbname, b.dbname); + swap(a.tablename, b.tablename); + swap(a.partname, b.partname); + swap(a.state, b.state); + swap(a.type, b.type); + swap(a.txnid, b.txnid); + swap(a.lastheartbeat, b.lastheartbeat); + swap(a.acquiredat, b.acquiredat); + swap(a.user, b.user); + swap(a.hostname, b.hostname); + swap(a.heartbeatCount, b.heartbeatCount); + swap(a.agentInfo, b.agentInfo); + swap(a.blockedByExtId, b.blockedByExtId); + swap(a.blockedByIntId, b.blockedByIntId); + swap(a.lockIdInternal, b.lockIdInternal); + swap(a.__isset, b.__isset); +} + +bool ShowLocksResponseElement::operator==(const ShowLocksResponseElement & rhs) const +{ + if (!(lockid == rhs.lockid)) + return false; + if (!(dbname == rhs.dbname)) + return false; + if (__isset.tablename != rhs.__isset.tablename) + return false; + else if (__isset.tablename && !(tablename == rhs.tablename)) + return false; + if (__isset.partname != rhs.__isset.partname) + return false; + else if (__isset.partname && !(partname == rhs.partname)) + return false; + if (!(state == rhs.state)) + return false; + if (!(type == rhs.type)) + return false; + if (__isset.txnid != rhs.__isset.txnid) + return false; + else if (__isset.txnid && !(txnid == rhs.txnid)) + return false; + if (!(lastheartbeat == rhs.lastheartbeat)) + return false; + if (__isset.acquiredat != rhs.__isset.acquiredat) + return false; + else if (__isset.acquiredat && !(acquiredat == rhs.acquiredat)) + return false; + if (!(user == rhs.user)) + return false; + if (!(hostname == rhs.hostname)) + return false; + if (__isset.heartbeatCount != rhs.__isset.heartbeatCount) + return false; + else if (__isset.heartbeatCount && !(heartbeatCount == rhs.heartbeatCount)) + return false; + if (__isset.agentInfo != rhs.__isset.agentInfo) + return false; + else if (__isset.agentInfo && !(agentInfo == rhs.agentInfo)) + return false; + if (__isset.blockedByExtId != rhs.__isset.blockedByExtId) + return false; + else if (__isset.blockedByExtId && !(blockedByExtId == rhs.blockedByExtId)) + return false; + if (__isset.blockedByIntId != rhs.__isset.blockedByIntId) + return false; + else if (__isset.blockedByIntId && !(blockedByIntId == rhs.blockedByIntId)) + return false; + if (__isset.lockIdInternal != rhs.__isset.lockIdInternal) + return false; + else if (__isset.lockIdInternal && !(lockIdInternal == rhs.lockIdInternal)) + return false; + return true; +} + +ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other995) { + lockid = other995.lockid; + dbname = other995.dbname; + tablename = other995.tablename; + partname = other995.partname; + state = other995.state; + type = other995.type; + txnid = other995.txnid; + lastheartbeat = other995.lastheartbeat; + acquiredat = other995.acquiredat; + user = other995.user; + hostname = other995.hostname; + heartbeatCount = other995.heartbeatCount; + agentInfo = other995.agentInfo; + blockedByExtId = other995.blockedByExtId; + blockedByIntId = other995.blockedByIntId; + lockIdInternal = other995.lockIdInternal; + __isset = other995.__isset; +} +ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other996) { + lockid = other996.lockid; + dbname = other996.dbname; + tablename = other996.tablename; + partname = other996.partname; + state = other996.state; + type = other996.type; + txnid = other996.txnid; + lastheartbeat = other996.lastheartbeat; + acquiredat = other996.acquiredat; + user = other996.user; + hostname = other996.hostname; + heartbeatCount = other996.heartbeatCount; + agentInfo = other996.agentInfo; + blockedByExtId = other996.blockedByExtId; + blockedByIntId = other996.blockedByIntId; + lockIdInternal = other996.lockIdInternal; + __isset = other996.__isset; + return *this; +} +void ShowLocksResponseElement::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ShowLocksResponseElement("; + out << "lockid=" << to_string(lockid); + out << ", " << "dbname=" << to_string(dbname); + out << ", " << "tablename="; (__isset.tablename ? (out << to_string(tablename)) : (out << "")); + out << ", " << "partname="; (__isset.partname ? (out << to_string(partname)) : (out << "")); + out << ", " << "state=" << to_string(state); + out << ", " << "type=" << to_string(type); + out << ", " << "txnid="; (__isset.txnid ? (out << to_string(txnid)) : (out << "")); + out << ", " << "lastheartbeat=" << to_string(lastheartbeat); + out << ", " << "acquiredat="; (__isset.acquiredat ? (out << to_string(acquiredat)) : (out << "")); + out << ", " << "user=" << to_string(user); + out << ", " << "hostname=" << to_string(hostname); + out << ", " << "heartbeatCount="; (__isset.heartbeatCount ? (out << to_string(heartbeatCount)) : (out << "")); + out << ", " << "agentInfo="; (__isset.agentInfo ? (out << to_string(agentInfo)) : (out << "")); + out << ", " << "blockedByExtId="; (__isset.blockedByExtId ? (out << to_string(blockedByExtId)) : (out << "")); + out << ", " << "blockedByIntId="; (__isset.blockedByIntId ? (out << to_string(blockedByIntId)) : (out << "")); + out << ", " << "lockIdInternal="; (__isset.lockIdInternal ? (out << to_string(lockIdInternal)) : (out << "")); + out << ")"; +} + + +ShowLocksResponse::~ShowLocksResponse() noexcept { +} + +ShowLocksResponse::ShowLocksResponse() noexcept { +} + +void ShowLocksResponse::__set_locks(const std::vector & val) { + this->locks = val; +} +std::ostream& operator<<(std::ostream& out, const ShowLocksResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ShowLocksResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->locks.clear(); + uint32_t _size997; + ::apache::thrift::protocol::TType _etype1000; + xfer += iprot->readListBegin(_etype1000, _size997); + this->locks.resize(_size997); + uint32_t _i1001; + for (_i1001 = 0; _i1001 < _size997; ++_i1001) + { + xfer += this->locks[_i1001].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.locks = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ShowLocksResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ShowLocksResponse"); + + xfer += oprot->writeFieldBegin("locks", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->locks.size())); + std::vector ::const_iterator _iter1002; + for (_iter1002 = this->locks.begin(); _iter1002 != this->locks.end(); ++_iter1002) + { + xfer += (*_iter1002).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ShowLocksResponse &a, ShowLocksResponse &b) noexcept { + using ::std::swap; + swap(a.locks, b.locks); + swap(a.__isset, b.__isset); +} + +bool ShowLocksResponse::operator==(const ShowLocksResponse & rhs) const +{ + if (!(locks == rhs.locks)) + return false; + return true; +} + +ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other1003) { + locks = other1003.locks; + __isset = other1003.__isset; +} +ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other1004) { + locks = other1004.locks; + __isset = other1004.__isset; + return *this; +} +void ShowLocksResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ShowLocksResponse("; + out << "locks=" << to_string(locks); + out << ")"; +} + + +HeartbeatRequest::~HeartbeatRequest() noexcept { +} + +HeartbeatRequest::HeartbeatRequest() noexcept + : lockid(0), + txnid(0) { +} + +void HeartbeatRequest::__set_lockid(const int64_t val) { + this->lockid = val; +__isset.lockid = true; +} + +void HeartbeatRequest::__set_txnid(const int64_t val) { + this->txnid = val; +__isset.txnid = true; +} +std::ostream& operator<<(std::ostream& out, const HeartbeatRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t HeartbeatRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->lockid); + this->__isset.lockid = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnid); + this->__isset.txnid = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t HeartbeatRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("HeartbeatRequest"); + + if (this->__isset.lockid) { + xfer += oprot->writeFieldBegin("lockid", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->lockid); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.txnid) { + xfer += oprot->writeFieldBegin("txnid", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->txnid); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(HeartbeatRequest &a, HeartbeatRequest &b) noexcept { + using ::std::swap; + swap(a.lockid, b.lockid); + swap(a.txnid, b.txnid); + swap(a.__isset, b.__isset); +} + +bool HeartbeatRequest::operator==(const HeartbeatRequest & rhs) const +{ + if (__isset.lockid != rhs.__isset.lockid) + return false; + else if (__isset.lockid && !(lockid == rhs.lockid)) + return false; + if (__isset.txnid != rhs.__isset.txnid) + return false; + else if (__isset.txnid && !(txnid == rhs.txnid)) + return false; + return true; +} + +HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other1005) noexcept { + lockid = other1005.lockid; + txnid = other1005.txnid; + __isset = other1005.__isset; +} +HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other1006) noexcept { + lockid = other1006.lockid; + txnid = other1006.txnid; + __isset = other1006.__isset; + return *this; +} +void HeartbeatRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "HeartbeatRequest("; + out << "lockid="; (__isset.lockid ? (out << to_string(lockid)) : (out << "")); + out << ", " << "txnid="; (__isset.txnid ? (out << to_string(txnid)) : (out << "")); + out << ")"; +} + + +HeartbeatTxnRangeRequest::~HeartbeatTxnRangeRequest() noexcept { +} + +HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest() noexcept + : min(0), + max(0) { +} + +void HeartbeatTxnRangeRequest::__set_min(const int64_t val) { + this->min = val; +} + +void HeartbeatTxnRangeRequest::__set_max(const int64_t val) { + this->max = val; +} +std::ostream& operator<<(std::ostream& out, const HeartbeatTxnRangeRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t HeartbeatTxnRangeRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_min = false; + bool isset_max = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->min); + isset_min = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->max); + isset_max = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_min) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_max) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t HeartbeatTxnRangeRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("HeartbeatTxnRangeRequest"); + + xfer += oprot->writeFieldBegin("min", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->min); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->max); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b) noexcept { + using ::std::swap; + swap(a.min, b.min); + swap(a.max, b.max); +} + +bool HeartbeatTxnRangeRequest::operator==(const HeartbeatTxnRangeRequest & rhs) const +{ + if (!(min == rhs.min)) + return false; + if (!(max == rhs.max)) + return false; + return true; +} + +HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other1007) noexcept { + min = other1007.min; + max = other1007.max; +} +HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other1008) noexcept { + min = other1008.min; + max = other1008.max; + return *this; +} +void HeartbeatTxnRangeRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "HeartbeatTxnRangeRequest("; + out << "min=" << to_string(min); + out << ", " << "max=" << to_string(max); + out << ")"; +} + + +HeartbeatTxnRangeResponse::~HeartbeatTxnRangeResponse() noexcept { +} + +HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse() noexcept { +} + +void HeartbeatTxnRangeResponse::__set_aborted(const std::set & val) { + this->aborted = val; +} + +void HeartbeatTxnRangeResponse::__set_nosuch(const std::set & val) { + this->nosuch = val; +} +std::ostream& operator<<(std::ostream& out, const HeartbeatTxnRangeResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_aborted = false; + bool isset_nosuch = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_SET) { + { + this->aborted.clear(); + uint32_t _size1009; + ::apache::thrift::protocol::TType _etype1012; + xfer += iprot->readSetBegin(_etype1012, _size1009); + uint32_t _i1013; + for (_i1013 = 0; _i1013 < _size1009; ++_i1013) + { + int64_t _elem1014; + xfer += iprot->readI64(_elem1014); + this->aborted.insert(_elem1014); + } + xfer += iprot->readSetEnd(); + } + isset_aborted = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_SET) { + { + this->nosuch.clear(); + uint32_t _size1015; + ::apache::thrift::protocol::TType _etype1018; + xfer += iprot->readSetBegin(_etype1018, _size1015); + uint32_t _i1019; + for (_i1019 = 0; _i1019 < _size1015; ++_i1019) + { + int64_t _elem1020; + xfer += iprot->readI64(_elem1020); + this->nosuch.insert(_elem1020); + } + xfer += iprot->readSetEnd(); + } + isset_nosuch = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_aborted) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_nosuch) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t HeartbeatTxnRangeResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("HeartbeatTxnRangeResponse"); + + xfer += oprot->writeFieldBegin("aborted", ::apache::thrift::protocol::T_SET, 1); + { + xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast(this->aborted.size())); + std::set ::const_iterator _iter1021; + for (_iter1021 = this->aborted.begin(); _iter1021 != this->aborted.end(); ++_iter1021) + { + xfer += oprot->writeI64((*_iter1021)); + } + xfer += oprot->writeSetEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("nosuch", ::apache::thrift::protocol::T_SET, 2); + { + xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast(this->nosuch.size())); + std::set ::const_iterator _iter1022; + for (_iter1022 = this->nosuch.begin(); _iter1022 != this->nosuch.end(); ++_iter1022) + { + xfer += oprot->writeI64((*_iter1022)); + } + xfer += oprot->writeSetEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b) noexcept { + using ::std::swap; + swap(a.aborted, b.aborted); + swap(a.nosuch, b.nosuch); +} + +bool HeartbeatTxnRangeResponse::operator==(const HeartbeatTxnRangeResponse & rhs) const +{ + if (!(aborted == rhs.aborted)) + return false; + if (!(nosuch == rhs.nosuch)) + return false; + return true; +} + +HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other1023) { + aborted = other1023.aborted; + nosuch = other1023.nosuch; +} +HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other1024) { + aborted = other1024.aborted; + nosuch = other1024.nosuch; + return *this; +} +void HeartbeatTxnRangeResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "HeartbeatTxnRangeResponse("; + out << "aborted=" << to_string(aborted); + out << ", " << "nosuch=" << to_string(nosuch); + out << ")"; +} + + +CompactionRequest::~CompactionRequest() noexcept { +} + +CompactionRequest::CompactionRequest() noexcept + : dbname(), + tablename(), + partitionname(), + type(static_cast(0)), + runas(), + initiatorId(), + initiatorVersion(), + poolName(), + numberOfBuckets(0), + orderByClause() { +} + +void CompactionRequest::__set_dbname(const std::string& val) { + this->dbname = val; +} + +void CompactionRequest::__set_tablename(const std::string& val) { + this->tablename = val; +} + +void CompactionRequest::__set_partitionname(const std::string& val) { + this->partitionname = val; +__isset.partitionname = true; +} + +void CompactionRequest::__set_type(const CompactionType::type val) { + this->type = val; +} + +void CompactionRequest::__set_runas(const std::string& val) { + this->runas = val; +__isset.runas = true; +} + +void CompactionRequest::__set_properties(const std::map & val) { + this->properties = val; +__isset.properties = true; +} + +void CompactionRequest::__set_initiatorId(const std::string& val) { + this->initiatorId = val; +__isset.initiatorId = true; +} + +void CompactionRequest::__set_initiatorVersion(const std::string& val) { + this->initiatorVersion = val; +__isset.initiatorVersion = true; +} + +void CompactionRequest::__set_poolName(const std::string& val) { + this->poolName = val; +__isset.poolName = true; +} + +void CompactionRequest::__set_numberOfBuckets(const int32_t val) { + this->numberOfBuckets = val; +__isset.numberOfBuckets = true; +} + +void CompactionRequest::__set_orderByClause(const std::string& val) { + this->orderByClause = val; +__isset.orderByClause = true; +} +std::ostream& operator<<(std::ostream& out, const CompactionRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbname = false; + bool isset_tablename = false; + bool isset_type = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbname); + isset_dbname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tablename); + isset_tablename = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->partitionname); + this->__isset.partitionname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1025; + xfer += iprot->readI32(ecast1025); + this->type = static_cast(ecast1025); + isset_type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->runas); + this->__isset.runas = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->properties.clear(); + uint32_t _size1026; + ::apache::thrift::protocol::TType _ktype1027; + ::apache::thrift::protocol::TType _vtype1028; + xfer += iprot->readMapBegin(_ktype1027, _vtype1028, _size1026); + uint32_t _i1030; + for (_i1030 = 0; _i1030 < _size1026; ++_i1030) + { + std::string _key1031; + xfer += iprot->readString(_key1031); + std::string& _val1032 = this->properties[_key1031]; + xfer += iprot->readString(_val1032); + } + xfer += iprot->readMapEnd(); + } + this->__isset.properties = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->initiatorId); + this->__isset.initiatorId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->initiatorVersion); + this->__isset.initiatorVersion = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->poolName); + this->__isset.poolName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->numberOfBuckets); + this->__isset.numberOfBuckets = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 11: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->orderByClause); + this->__isset.orderByClause = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbname) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tablename) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_type) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t CompactionRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CompactionRequest"); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbname); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tablename", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tablename); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.partitionname) { + xfer += oprot->writeFieldBegin("partitionname", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->partitionname); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32(static_cast(this->type)); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.runas) { + xfer += oprot->writeFieldBegin("runas", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->runas); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.properties) { + xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 6); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->properties.size())); + std::map ::const_iterator _iter1033; + for (_iter1033 = this->properties.begin(); _iter1033 != this->properties.end(); ++_iter1033) + { + xfer += oprot->writeString(_iter1033->first); + xfer += oprot->writeString(_iter1033->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.initiatorId) { + xfer += oprot->writeFieldBegin("initiatorId", ::apache::thrift::protocol::T_STRING, 7); + xfer += oprot->writeString(this->initiatorId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.initiatorVersion) { + xfer += oprot->writeFieldBegin("initiatorVersion", ::apache::thrift::protocol::T_STRING, 8); + xfer += oprot->writeString(this->initiatorVersion); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.poolName) { + xfer += oprot->writeFieldBegin("poolName", ::apache::thrift::protocol::T_STRING, 9); + xfer += oprot->writeString(this->poolName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.numberOfBuckets) { + xfer += oprot->writeFieldBegin("numberOfBuckets", ::apache::thrift::protocol::T_I32, 10); + xfer += oprot->writeI32(this->numberOfBuckets); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.orderByClause) { + xfer += oprot->writeFieldBegin("orderByClause", ::apache::thrift::protocol::T_STRING, 11); + xfer += oprot->writeString(this->orderByClause); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CompactionRequest &a, CompactionRequest &b) noexcept { + using ::std::swap; + swap(a.dbname, b.dbname); + swap(a.tablename, b.tablename); + swap(a.partitionname, b.partitionname); + swap(a.type, b.type); + swap(a.runas, b.runas); + swap(a.properties, b.properties); + swap(a.initiatorId, b.initiatorId); + swap(a.initiatorVersion, b.initiatorVersion); + swap(a.poolName, b.poolName); + swap(a.numberOfBuckets, b.numberOfBuckets); + swap(a.orderByClause, b.orderByClause); + swap(a.__isset, b.__isset); +} + +bool CompactionRequest::operator==(const CompactionRequest & rhs) const +{ + if (!(dbname == rhs.dbname)) + return false; + if (!(tablename == rhs.tablename)) + return false; + if (__isset.partitionname != rhs.__isset.partitionname) + return false; + else if (__isset.partitionname && !(partitionname == rhs.partitionname)) + return false; + if (!(type == rhs.type)) + return false; + if (__isset.runas != rhs.__isset.runas) + return false; + else if (__isset.runas && !(runas == rhs.runas)) + return false; + if (__isset.properties != rhs.__isset.properties) + return false; + else if (__isset.properties && !(properties == rhs.properties)) + return false; + if (__isset.initiatorId != rhs.__isset.initiatorId) + return false; + else if (__isset.initiatorId && !(initiatorId == rhs.initiatorId)) + return false; + if (__isset.initiatorVersion != rhs.__isset.initiatorVersion) + return false; + else if (__isset.initiatorVersion && !(initiatorVersion == rhs.initiatorVersion)) + return false; + if (__isset.poolName != rhs.__isset.poolName) + return false; + else if (__isset.poolName && !(poolName == rhs.poolName)) + return false; + if (__isset.numberOfBuckets != rhs.__isset.numberOfBuckets) + return false; + else if (__isset.numberOfBuckets && !(numberOfBuckets == rhs.numberOfBuckets)) + return false; + if (__isset.orderByClause != rhs.__isset.orderByClause) + return false; + else if (__isset.orderByClause && !(orderByClause == rhs.orderByClause)) + return false; + return true; +} + +CompactionRequest::CompactionRequest(const CompactionRequest& other1034) { + dbname = other1034.dbname; + tablename = other1034.tablename; + partitionname = other1034.partitionname; + type = other1034.type; + runas = other1034.runas; + properties = other1034.properties; + initiatorId = other1034.initiatorId; + initiatorVersion = other1034.initiatorVersion; + poolName = other1034.poolName; + numberOfBuckets = other1034.numberOfBuckets; + orderByClause = other1034.orderByClause; + __isset = other1034.__isset; +} +CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other1035) { + dbname = other1035.dbname; + tablename = other1035.tablename; + partitionname = other1035.partitionname; + type = other1035.type; + runas = other1035.runas; + properties = other1035.properties; + initiatorId = other1035.initiatorId; + initiatorVersion = other1035.initiatorVersion; + poolName = other1035.poolName; + numberOfBuckets = other1035.numberOfBuckets; + orderByClause = other1035.orderByClause; + __isset = other1035.__isset; + return *this; +} +void CompactionRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CompactionRequest("; + out << "dbname=" << to_string(dbname); + out << ", " << "tablename=" << to_string(tablename); + out << ", " << "partitionname="; (__isset.partitionname ? (out << to_string(partitionname)) : (out << "")); + out << ", " << "type=" << to_string(type); + out << ", " << "runas="; (__isset.runas ? (out << to_string(runas)) : (out << "")); + out << ", " << "properties="; (__isset.properties ? (out << to_string(properties)) : (out << "")); + out << ", " << "initiatorId="; (__isset.initiatorId ? (out << to_string(initiatorId)) : (out << "")); + out << ", " << "initiatorVersion="; (__isset.initiatorVersion ? (out << to_string(initiatorVersion)) : (out << "")); + out << ", " << "poolName="; (__isset.poolName ? (out << to_string(poolName)) : (out << "")); + out << ", " << "numberOfBuckets="; (__isset.numberOfBuckets ? (out << to_string(numberOfBuckets)) : (out << "")); + out << ", " << "orderByClause="; (__isset.orderByClause ? (out << to_string(orderByClause)) : (out << "")); + out << ")"; +} + + +CompactionInfoStruct::~CompactionInfoStruct() noexcept { +} + +CompactionInfoStruct::CompactionInfoStruct() noexcept + : id(0), + dbname(), + tablename(), + partitionname(), + type(static_cast(0)), + runas(), + properties(), + toomanyaborts(0), + state(), + workerId(), + start(0), + highestWriteId(0), + errorMessage(), + hasoldabort(0), + enqueueTime(0), + retryRetention(0), + poolname(), + numberOfBuckets(0), + orderByClause() { +} + +void CompactionInfoStruct::__set_id(const int64_t val) { + this->id = val; +} + +void CompactionInfoStruct::__set_dbname(const std::string& val) { + this->dbname = val; +} + +void CompactionInfoStruct::__set_tablename(const std::string& val) { + this->tablename = val; +} + +void CompactionInfoStruct::__set_partitionname(const std::string& val) { + this->partitionname = val; +__isset.partitionname = true; +} + +void CompactionInfoStruct::__set_type(const CompactionType::type val) { + this->type = val; +} + +void CompactionInfoStruct::__set_runas(const std::string& val) { + this->runas = val; +__isset.runas = true; +} + +void CompactionInfoStruct::__set_properties(const std::string& val) { + this->properties = val; +__isset.properties = true; +} + +void CompactionInfoStruct::__set_toomanyaborts(const bool val) { + this->toomanyaborts = val; +__isset.toomanyaborts = true; +} + +void CompactionInfoStruct::__set_state(const std::string& val) { + this->state = val; +__isset.state = true; +} + +void CompactionInfoStruct::__set_workerId(const std::string& val) { + this->workerId = val; +__isset.workerId = true; +} + +void CompactionInfoStruct::__set_start(const int64_t val) { + this->start = val; +__isset.start = true; +} + +void CompactionInfoStruct::__set_highestWriteId(const int64_t val) { + this->highestWriteId = val; +__isset.highestWriteId = true; +} + +void CompactionInfoStruct::__set_errorMessage(const std::string& val) { + this->errorMessage = val; +__isset.errorMessage = true; +} + +void CompactionInfoStruct::__set_hasoldabort(const bool val) { + this->hasoldabort = val; +__isset.hasoldabort = true; +} + +void CompactionInfoStruct::__set_enqueueTime(const int64_t val) { + this->enqueueTime = val; +__isset.enqueueTime = true; +} + +void CompactionInfoStruct::__set_retryRetention(const int64_t val) { + this->retryRetention = val; +__isset.retryRetention = true; +} + +void CompactionInfoStruct::__set_poolname(const std::string& val) { + this->poolname = val; +__isset.poolname = true; +} + +void CompactionInfoStruct::__set_numberOfBuckets(const int32_t val) { + this->numberOfBuckets = val; +__isset.numberOfBuckets = true; +} + +void CompactionInfoStruct::__set_orderByClause(const std::string& val) { + this->orderByClause = val; +__isset.orderByClause = true; +} +std::ostream& operator<<(std::ostream& out, const CompactionInfoStruct& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t CompactionInfoStruct::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_id = false; + bool isset_dbname = false; + bool isset_tablename = false; + bool isset_type = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->id); + isset_id = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbname); + isset_dbname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tablename); + isset_tablename = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->partitionname); + this->__isset.partitionname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1036; + xfer += iprot->readI32(ecast1036); + this->type = static_cast(ecast1036); + isset_type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->runas); + this->__isset.runas = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->properties); + this->__isset.properties = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->toomanyaborts); + this->__isset.toomanyaborts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->state); + this->__isset.state = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->workerId); + this->__isset.workerId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 11: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->start); + this->__isset.start = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 12: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->highestWriteId); + this->__isset.highestWriteId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 13: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->errorMessage); + this->__isset.errorMessage = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 14: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->hasoldabort); + this->__isset.hasoldabort = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 15: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->enqueueTime); + this->__isset.enqueueTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 16: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->retryRetention); + this->__isset.retryRetention = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 17: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->poolname); + this->__isset.poolname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 18: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->numberOfBuckets); + this->__isset.numberOfBuckets = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 19: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->orderByClause); + this->__isset.orderByClause = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_id) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_dbname) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tablename) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_type) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t CompactionInfoStruct::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CompactionInfoStruct"); + + xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->id); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbname); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tablename", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tablename); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.partitionname) { + xfer += oprot->writeFieldBegin("partitionname", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->partitionname); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 5); + xfer += oprot->writeI32(static_cast(this->type)); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.runas) { + xfer += oprot->writeFieldBegin("runas", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->runas); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.properties) { + xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_STRING, 7); + xfer += oprot->writeString(this->properties); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.toomanyaborts) { + xfer += oprot->writeFieldBegin("toomanyaborts", ::apache::thrift::protocol::T_BOOL, 8); + xfer += oprot->writeBool(this->toomanyaborts); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.state) { + xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_STRING, 9); + xfer += oprot->writeString(this->state); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.workerId) { + xfer += oprot->writeFieldBegin("workerId", ::apache::thrift::protocol::T_STRING, 10); + xfer += oprot->writeString(this->workerId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.start) { + xfer += oprot->writeFieldBegin("start", ::apache::thrift::protocol::T_I64, 11); + xfer += oprot->writeI64(this->start); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.highestWriteId) { + xfer += oprot->writeFieldBegin("highestWriteId", ::apache::thrift::protocol::T_I64, 12); + xfer += oprot->writeI64(this->highestWriteId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.errorMessage) { + xfer += oprot->writeFieldBegin("errorMessage", ::apache::thrift::protocol::T_STRING, 13); + xfer += oprot->writeString(this->errorMessage); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.hasoldabort) { + xfer += oprot->writeFieldBegin("hasoldabort", ::apache::thrift::protocol::T_BOOL, 14); + xfer += oprot->writeBool(this->hasoldabort); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.enqueueTime) { + xfer += oprot->writeFieldBegin("enqueueTime", ::apache::thrift::protocol::T_I64, 15); + xfer += oprot->writeI64(this->enqueueTime); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.retryRetention) { + xfer += oprot->writeFieldBegin("retryRetention", ::apache::thrift::protocol::T_I64, 16); + xfer += oprot->writeI64(this->retryRetention); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.poolname) { + xfer += oprot->writeFieldBegin("poolname", ::apache::thrift::protocol::T_STRING, 17); + xfer += oprot->writeString(this->poolname); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.numberOfBuckets) { + xfer += oprot->writeFieldBegin("numberOfBuckets", ::apache::thrift::protocol::T_I32, 18); + xfer += oprot->writeI32(this->numberOfBuckets); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.orderByClause) { + xfer += oprot->writeFieldBegin("orderByClause", ::apache::thrift::protocol::T_STRING, 19); + xfer += oprot->writeString(this->orderByClause); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CompactionInfoStruct &a, CompactionInfoStruct &b) noexcept { + using ::std::swap; + swap(a.id, b.id); + swap(a.dbname, b.dbname); + swap(a.tablename, b.tablename); + swap(a.partitionname, b.partitionname); + swap(a.type, b.type); + swap(a.runas, b.runas); + swap(a.properties, b.properties); + swap(a.toomanyaborts, b.toomanyaborts); + swap(a.state, b.state); + swap(a.workerId, b.workerId); + swap(a.start, b.start); + swap(a.highestWriteId, b.highestWriteId); + swap(a.errorMessage, b.errorMessage); + swap(a.hasoldabort, b.hasoldabort); + swap(a.enqueueTime, b.enqueueTime); + swap(a.retryRetention, b.retryRetention); + swap(a.poolname, b.poolname); + swap(a.numberOfBuckets, b.numberOfBuckets); + swap(a.orderByClause, b.orderByClause); + swap(a.__isset, b.__isset); +} + +bool CompactionInfoStruct::operator==(const CompactionInfoStruct & rhs) const +{ + if (!(id == rhs.id)) + return false; + if (!(dbname == rhs.dbname)) + return false; + if (!(tablename == rhs.tablename)) + return false; + if (__isset.partitionname != rhs.__isset.partitionname) + return false; + else if (__isset.partitionname && !(partitionname == rhs.partitionname)) + return false; + if (!(type == rhs.type)) + return false; + if (__isset.runas != rhs.__isset.runas) + return false; + else if (__isset.runas && !(runas == rhs.runas)) + return false; + if (__isset.properties != rhs.__isset.properties) + return false; + else if (__isset.properties && !(properties == rhs.properties)) + return false; + if (__isset.toomanyaborts != rhs.__isset.toomanyaborts) + return false; + else if (__isset.toomanyaborts && !(toomanyaborts == rhs.toomanyaborts)) + return false; + if (__isset.state != rhs.__isset.state) + return false; + else if (__isset.state && !(state == rhs.state)) + return false; + if (__isset.workerId != rhs.__isset.workerId) + return false; + else if (__isset.workerId && !(workerId == rhs.workerId)) + return false; + if (__isset.start != rhs.__isset.start) + return false; + else if (__isset.start && !(start == rhs.start)) + return false; + if (__isset.highestWriteId != rhs.__isset.highestWriteId) + return false; + else if (__isset.highestWriteId && !(highestWriteId == rhs.highestWriteId)) + return false; + if (__isset.errorMessage != rhs.__isset.errorMessage) + return false; + else if (__isset.errorMessage && !(errorMessage == rhs.errorMessage)) + return false; + if (__isset.hasoldabort != rhs.__isset.hasoldabort) + return false; + else if (__isset.hasoldabort && !(hasoldabort == rhs.hasoldabort)) + return false; + if (__isset.enqueueTime != rhs.__isset.enqueueTime) + return false; + else if (__isset.enqueueTime && !(enqueueTime == rhs.enqueueTime)) + return false; + if (__isset.retryRetention != rhs.__isset.retryRetention) + return false; + else if (__isset.retryRetention && !(retryRetention == rhs.retryRetention)) + return false; + if (__isset.poolname != rhs.__isset.poolname) + return false; + else if (__isset.poolname && !(poolname == rhs.poolname)) + return false; + if (__isset.numberOfBuckets != rhs.__isset.numberOfBuckets) + return false; + else if (__isset.numberOfBuckets && !(numberOfBuckets == rhs.numberOfBuckets)) + return false; + if (__isset.orderByClause != rhs.__isset.orderByClause) + return false; + else if (__isset.orderByClause && !(orderByClause == rhs.orderByClause)) + return false; + return true; +} + +CompactionInfoStruct::CompactionInfoStruct(const CompactionInfoStruct& other1037) { + id = other1037.id; + dbname = other1037.dbname; + tablename = other1037.tablename; + partitionname = other1037.partitionname; + type = other1037.type; + runas = other1037.runas; + properties = other1037.properties; + toomanyaborts = other1037.toomanyaborts; + state = other1037.state; + workerId = other1037.workerId; + start = other1037.start; + highestWriteId = other1037.highestWriteId; + errorMessage = other1037.errorMessage; + hasoldabort = other1037.hasoldabort; + enqueueTime = other1037.enqueueTime; + retryRetention = other1037.retryRetention; + poolname = other1037.poolname; + numberOfBuckets = other1037.numberOfBuckets; + orderByClause = other1037.orderByClause; + __isset = other1037.__isset; +} +CompactionInfoStruct& CompactionInfoStruct::operator=(const CompactionInfoStruct& other1038) { + id = other1038.id; + dbname = other1038.dbname; + tablename = other1038.tablename; + partitionname = other1038.partitionname; + type = other1038.type; + runas = other1038.runas; + properties = other1038.properties; + toomanyaborts = other1038.toomanyaborts; + state = other1038.state; + workerId = other1038.workerId; + start = other1038.start; + highestWriteId = other1038.highestWriteId; + errorMessage = other1038.errorMessage; + hasoldabort = other1038.hasoldabort; + enqueueTime = other1038.enqueueTime; + retryRetention = other1038.retryRetention; + poolname = other1038.poolname; + numberOfBuckets = other1038.numberOfBuckets; + orderByClause = other1038.orderByClause; + __isset = other1038.__isset; + return *this; +} +void CompactionInfoStruct::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CompactionInfoStruct("; + out << "id=" << to_string(id); + out << ", " << "dbname=" << to_string(dbname); + out << ", " << "tablename=" << to_string(tablename); + out << ", " << "partitionname="; (__isset.partitionname ? (out << to_string(partitionname)) : (out << "")); + out << ", " << "type=" << to_string(type); + out << ", " << "runas="; (__isset.runas ? (out << to_string(runas)) : (out << "")); + out << ", " << "properties="; (__isset.properties ? (out << to_string(properties)) : (out << "")); + out << ", " << "toomanyaborts="; (__isset.toomanyaborts ? (out << to_string(toomanyaborts)) : (out << "")); + out << ", " << "state="; (__isset.state ? (out << to_string(state)) : (out << "")); + out << ", " << "workerId="; (__isset.workerId ? (out << to_string(workerId)) : (out << "")); + out << ", " << "start="; (__isset.start ? (out << to_string(start)) : (out << "")); + out << ", " << "highestWriteId="; (__isset.highestWriteId ? (out << to_string(highestWriteId)) : (out << "")); + out << ", " << "errorMessage="; (__isset.errorMessage ? (out << to_string(errorMessage)) : (out << "")); + out << ", " << "hasoldabort="; (__isset.hasoldabort ? (out << to_string(hasoldabort)) : (out << "")); + out << ", " << "enqueueTime="; (__isset.enqueueTime ? (out << to_string(enqueueTime)) : (out << "")); + out << ", " << "retryRetention="; (__isset.retryRetention ? (out << to_string(retryRetention)) : (out << "")); + out << ", " << "poolname="; (__isset.poolname ? (out << to_string(poolname)) : (out << "")); + out << ", " << "numberOfBuckets="; (__isset.numberOfBuckets ? (out << to_string(numberOfBuckets)) : (out << "")); + out << ", " << "orderByClause="; (__isset.orderByClause ? (out << to_string(orderByClause)) : (out << "")); + out << ")"; +} + + +OptionalCompactionInfoStruct::~OptionalCompactionInfoStruct() noexcept { +} + +OptionalCompactionInfoStruct::OptionalCompactionInfoStruct() noexcept { +} + +void OptionalCompactionInfoStruct::__set_ci(const CompactionInfoStruct& val) { + this->ci = val; +__isset.ci = true; +} +std::ostream& operator<<(std::ostream& out, const OptionalCompactionInfoStruct& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t OptionalCompactionInfoStruct::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ci.read(iprot); + this->__isset.ci = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t OptionalCompactionInfoStruct::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("OptionalCompactionInfoStruct"); + + if (this->__isset.ci) { + xfer += oprot->writeFieldBegin("ci", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->ci.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(OptionalCompactionInfoStruct &a, OptionalCompactionInfoStruct &b) noexcept { + using ::std::swap; + swap(a.ci, b.ci); + swap(a.__isset, b.__isset); +} + +bool OptionalCompactionInfoStruct::operator==(const OptionalCompactionInfoStruct & rhs) const +{ + if (__isset.ci != rhs.__isset.ci) + return false; + else if (__isset.ci && !(ci == rhs.ci)) + return false; + return true; +} + +OptionalCompactionInfoStruct::OptionalCompactionInfoStruct(const OptionalCompactionInfoStruct& other1039) { + ci = other1039.ci; + __isset = other1039.__isset; +} +OptionalCompactionInfoStruct& OptionalCompactionInfoStruct::operator=(const OptionalCompactionInfoStruct& other1040) { + ci = other1040.ci; + __isset = other1040.__isset; + return *this; +} +void OptionalCompactionInfoStruct::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "OptionalCompactionInfoStruct("; + out << "ci="; (__isset.ci ? (out << to_string(ci)) : (out << "")); + out << ")"; +} + + +CompactionMetricsDataStruct::~CompactionMetricsDataStruct() noexcept { +} + +CompactionMetricsDataStruct::CompactionMetricsDataStruct() noexcept + : dbname(), + tblname(), + partitionname(), + type(static_cast(0)), + metricvalue(0), + version(0), + threshold(0) { +} + +void CompactionMetricsDataStruct::__set_dbname(const std::string& val) { + this->dbname = val; +} + +void CompactionMetricsDataStruct::__set_tblname(const std::string& val) { + this->tblname = val; +} + +void CompactionMetricsDataStruct::__set_partitionname(const std::string& val) { + this->partitionname = val; +__isset.partitionname = true; +} + +void CompactionMetricsDataStruct::__set_type(const CompactionMetricsMetricType::type val) { + this->type = val; +} + +void CompactionMetricsDataStruct::__set_metricvalue(const int32_t val) { + this->metricvalue = val; +} + +void CompactionMetricsDataStruct::__set_version(const int32_t val) { + this->version = val; +} + +void CompactionMetricsDataStruct::__set_threshold(const int32_t val) { + this->threshold = val; +} +std::ostream& operator<<(std::ostream& out, const CompactionMetricsDataStruct& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t CompactionMetricsDataStruct::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbname = false; + bool isset_tblname = false; + bool isset_type = false; + bool isset_metricvalue = false; + bool isset_version = false; + bool isset_threshold = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbname); + isset_dbname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tblname); + isset_tblname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->partitionname); + this->__isset.partitionname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1041; + xfer += iprot->readI32(ecast1041); + this->type = static_cast(ecast1041); + isset_type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->metricvalue); + isset_metricvalue = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->version); + isset_version = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->threshold); + isset_threshold = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbname) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tblname) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_type) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_metricvalue) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_version) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_threshold) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t CompactionMetricsDataStruct::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CompactionMetricsDataStruct"); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbname); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tblname", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tblname); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.partitionname) { + xfer += oprot->writeFieldBegin("partitionname", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->partitionname); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32(static_cast(this->type)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("metricvalue", ::apache::thrift::protocol::T_I32, 5); + xfer += oprot->writeI32(this->metricvalue); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("version", ::apache::thrift::protocol::T_I32, 6); + xfer += oprot->writeI32(this->version); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("threshold", ::apache::thrift::protocol::T_I32, 7); + xfer += oprot->writeI32(this->threshold); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CompactionMetricsDataStruct &a, CompactionMetricsDataStruct &b) noexcept { + using ::std::swap; + swap(a.dbname, b.dbname); + swap(a.tblname, b.tblname); + swap(a.partitionname, b.partitionname); + swap(a.type, b.type); + swap(a.metricvalue, b.metricvalue); + swap(a.version, b.version); + swap(a.threshold, b.threshold); + swap(a.__isset, b.__isset); +} + +bool CompactionMetricsDataStruct::operator==(const CompactionMetricsDataStruct & rhs) const +{ + if (!(dbname == rhs.dbname)) + return false; + if (!(tblname == rhs.tblname)) + return false; + if (__isset.partitionname != rhs.__isset.partitionname) + return false; + else if (__isset.partitionname && !(partitionname == rhs.partitionname)) + return false; + if (!(type == rhs.type)) + return false; + if (!(metricvalue == rhs.metricvalue)) + return false; + if (!(version == rhs.version)) + return false; + if (!(threshold == rhs.threshold)) + return false; + return true; +} + +CompactionMetricsDataStruct::CompactionMetricsDataStruct(const CompactionMetricsDataStruct& other1042) { + dbname = other1042.dbname; + tblname = other1042.tblname; + partitionname = other1042.partitionname; + type = other1042.type; + metricvalue = other1042.metricvalue; + version = other1042.version; + threshold = other1042.threshold; + __isset = other1042.__isset; +} +CompactionMetricsDataStruct& CompactionMetricsDataStruct::operator=(const CompactionMetricsDataStruct& other1043) { + dbname = other1043.dbname; + tblname = other1043.tblname; + partitionname = other1043.partitionname; + type = other1043.type; + metricvalue = other1043.metricvalue; + version = other1043.version; + threshold = other1043.threshold; + __isset = other1043.__isset; + return *this; +} +void CompactionMetricsDataStruct::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CompactionMetricsDataStruct("; + out << "dbname=" << to_string(dbname); + out << ", " << "tblname=" << to_string(tblname); + out << ", " << "partitionname="; (__isset.partitionname ? (out << to_string(partitionname)) : (out << "")); + out << ", " << "type=" << to_string(type); + out << ", " << "metricvalue=" << to_string(metricvalue); + out << ", " << "version=" << to_string(version); + out << ", " << "threshold=" << to_string(threshold); + out << ")"; +} + + +CompactionMetricsDataResponse::~CompactionMetricsDataResponse() noexcept { +} + +CompactionMetricsDataResponse::CompactionMetricsDataResponse() noexcept { +} + +void CompactionMetricsDataResponse::__set_data(const CompactionMetricsDataStruct& val) { + this->data = val; +__isset.data = true; +} +std::ostream& operator<<(std::ostream& out, const CompactionMetricsDataResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t CompactionMetricsDataResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->data.read(iprot); + this->__isset.data = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t CompactionMetricsDataResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CompactionMetricsDataResponse"); + + if (this->__isset.data) { + xfer += oprot->writeFieldBegin("data", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->data.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CompactionMetricsDataResponse &a, CompactionMetricsDataResponse &b) noexcept { + using ::std::swap; + swap(a.data, b.data); + swap(a.__isset, b.__isset); +} + +bool CompactionMetricsDataResponse::operator==(const CompactionMetricsDataResponse & rhs) const +{ + if (__isset.data != rhs.__isset.data) + return false; + else if (__isset.data && !(data == rhs.data)) + return false; + return true; +} + +CompactionMetricsDataResponse::CompactionMetricsDataResponse(const CompactionMetricsDataResponse& other1044) { + data = other1044.data; + __isset = other1044.__isset; +} +CompactionMetricsDataResponse& CompactionMetricsDataResponse::operator=(const CompactionMetricsDataResponse& other1045) { + data = other1045.data; + __isset = other1045.__isset; + return *this; +} +void CompactionMetricsDataResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CompactionMetricsDataResponse("; + out << "data="; (__isset.data ? (out << to_string(data)) : (out << "")); + out << ")"; +} + + +CompactionMetricsDataRequest::~CompactionMetricsDataRequest() noexcept { +} + +CompactionMetricsDataRequest::CompactionMetricsDataRequest() noexcept + : dbName(), + tblName(), + partitionName(), + type(static_cast(0)) { +} + +void CompactionMetricsDataRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void CompactionMetricsDataRequest::__set_tblName(const std::string& val) { + this->tblName = val; +} + +void CompactionMetricsDataRequest::__set_partitionName(const std::string& val) { + this->partitionName = val; +__isset.partitionName = true; +} + +void CompactionMetricsDataRequest::__set_type(const CompactionMetricsMetricType::type val) { + this->type = val; +} +std::ostream& operator<<(std::ostream& out, const CompactionMetricsDataRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t CompactionMetricsDataRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tblName = false; + bool isset_type = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tblName); + isset_tblName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->partitionName); + this->__isset.partitionName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1046; + xfer += iprot->readI32(ecast1046); + this->type = static_cast(ecast1046); + isset_type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tblName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_type) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t CompactionMetricsDataRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CompactionMetricsDataRequest"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tblName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.partitionName) { + xfer += oprot->writeFieldBegin("partitionName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->partitionName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32(static_cast(this->type)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CompactionMetricsDataRequest &a, CompactionMetricsDataRequest &b) noexcept { + using ::std::swap; + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); + swap(a.partitionName, b.partitionName); + swap(a.type, b.type); + swap(a.__isset, b.__isset); +} + +bool CompactionMetricsDataRequest::operator==(const CompactionMetricsDataRequest & rhs) const +{ + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + if (__isset.partitionName != rhs.__isset.partitionName) + return false; + else if (__isset.partitionName && !(partitionName == rhs.partitionName)) + return false; + if (!(type == rhs.type)) + return false; + return true; +} + +CompactionMetricsDataRequest::CompactionMetricsDataRequest(const CompactionMetricsDataRequest& other1047) { + dbName = other1047.dbName; + tblName = other1047.tblName; + partitionName = other1047.partitionName; + type = other1047.type; + __isset = other1047.__isset; +} +CompactionMetricsDataRequest& CompactionMetricsDataRequest::operator=(const CompactionMetricsDataRequest& other1048) { + dbName = other1048.dbName; + tblName = other1048.tblName; + partitionName = other1048.partitionName; + type = other1048.type; + __isset = other1048.__isset; + return *this; +} +void CompactionMetricsDataRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CompactionMetricsDataRequest("; + out << "dbName=" << to_string(dbName); + out << ", " << "tblName=" << to_string(tblName); + out << ", " << "partitionName="; (__isset.partitionName ? (out << to_string(partitionName)) : (out << "")); + out << ", " << "type=" << to_string(type); + out << ")"; +} + + +CompactionResponse::~CompactionResponse() noexcept { +} + +CompactionResponse::CompactionResponse() noexcept + : id(0), + state(), + accepted(0), + errormessage() { +} + +void CompactionResponse::__set_id(const int64_t val) { + this->id = val; +} + +void CompactionResponse::__set_state(const std::string& val) { + this->state = val; +} + +void CompactionResponse::__set_accepted(const bool val) { + this->accepted = val; +} + +void CompactionResponse::__set_errormessage(const std::string& val) { + this->errormessage = val; +__isset.errormessage = true; +} +std::ostream& operator<<(std::ostream& out, const CompactionResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t CompactionResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_id = false; + bool isset_state = false; + bool isset_accepted = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->id); + isset_id = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->state); + isset_state = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->accepted); + isset_accepted = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->errormessage); + this->__isset.errormessage = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_id) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_state) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_accepted) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t CompactionResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CompactionResponse"); + + xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->id); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->state); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("accepted", ::apache::thrift::protocol::T_BOOL, 3); + xfer += oprot->writeBool(this->accepted); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.errormessage) { + xfer += oprot->writeFieldBegin("errormessage", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->errormessage); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CompactionResponse &a, CompactionResponse &b) noexcept { + using ::std::swap; + swap(a.id, b.id); + swap(a.state, b.state); + swap(a.accepted, b.accepted); + swap(a.errormessage, b.errormessage); + swap(a.__isset, b.__isset); +} + +bool CompactionResponse::operator==(const CompactionResponse & rhs) const +{ + if (!(id == rhs.id)) + return false; + if (!(state == rhs.state)) + return false; + if (!(accepted == rhs.accepted)) + return false; + if (__isset.errormessage != rhs.__isset.errormessage) + return false; + else if (__isset.errormessage && !(errormessage == rhs.errormessage)) + return false; + return true; +} + +CompactionResponse::CompactionResponse(const CompactionResponse& other1049) { + id = other1049.id; + state = other1049.state; + accepted = other1049.accepted; + errormessage = other1049.errormessage; + __isset = other1049.__isset; +} +CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other1050) { + id = other1050.id; + state = other1050.state; + accepted = other1050.accepted; + errormessage = other1050.errormessage; + __isset = other1050.__isset; + return *this; +} +void CompactionResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CompactionResponse("; + out << "id=" << to_string(id); + out << ", " << "state=" << to_string(state); + out << ", " << "accepted=" << to_string(accepted); + out << ", " << "errormessage="; (__isset.errormessage ? (out << to_string(errormessage)) : (out << "")); + out << ")"; +} + + +ShowCompactRequest::~ShowCompactRequest() noexcept { +} + +ShowCompactRequest::ShowCompactRequest() noexcept + : id(0), + poolName(), + dbName(), + tbName(), + partName(), + type(static_cast(0)), + state(), + limit(0), + order() { +} + +void ShowCompactRequest::__set_id(const int64_t val) { + this->id = val; +__isset.id = true; +} + +void ShowCompactRequest::__set_poolName(const std::string& val) { + this->poolName = val; +__isset.poolName = true; +} + +void ShowCompactRequest::__set_dbName(const std::string& val) { + this->dbName = val; +__isset.dbName = true; +} + +void ShowCompactRequest::__set_tbName(const std::string& val) { + this->tbName = val; +__isset.tbName = true; +} + +void ShowCompactRequest::__set_partName(const std::string& val) { + this->partName = val; +__isset.partName = true; +} + +void ShowCompactRequest::__set_type(const CompactionType::type val) { + this->type = val; +__isset.type = true; +} + +void ShowCompactRequest::__set_state(const std::string& val) { + this->state = val; +__isset.state = true; +} + +void ShowCompactRequest::__set_limit(const int64_t val) { + this->limit = val; +__isset.limit = true; +} + +void ShowCompactRequest::__set_order(const std::string& val) { + this->order = val; +__isset.order = true; +} +std::ostream& operator<<(std::ostream& out, const ShowCompactRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ShowCompactRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->id); + this->__isset.id = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->poolName); + this->__isset.poolName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbName); + this->__isset.tbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->partName); + this->__isset.partName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1051; + xfer += iprot->readI32(ecast1051); + this->type = static_cast(ecast1051); + this->__isset.type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->state); + this->__isset.state = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->limit); + this->__isset.limit = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->order); + this->__isset.order = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ShowCompactRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ShowCompactRequest"); + + if (this->__isset.id) { + xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->id); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.poolName) { + xfer += oprot->writeFieldBegin("poolName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->poolName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.dbName) { + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.tbName) { + xfer += oprot->writeFieldBegin("tbName", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->tbName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.partName) { + xfer += oprot->writeFieldBegin("partName", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->partName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.type) { + xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 6); + xfer += oprot->writeI32(static_cast(this->type)); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.state) { + xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_STRING, 7); + xfer += oprot->writeString(this->state); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.limit) { + xfer += oprot->writeFieldBegin("limit", ::apache::thrift::protocol::T_I64, 8); + xfer += oprot->writeI64(this->limit); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.order) { + xfer += oprot->writeFieldBegin("order", ::apache::thrift::protocol::T_STRING, 9); + xfer += oprot->writeString(this->order); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ShowCompactRequest &a, ShowCompactRequest &b) noexcept { + using ::std::swap; + swap(a.id, b.id); + swap(a.poolName, b.poolName); + swap(a.dbName, b.dbName); + swap(a.tbName, b.tbName); + swap(a.partName, b.partName); + swap(a.type, b.type); + swap(a.state, b.state); + swap(a.limit, b.limit); + swap(a.order, b.order); + swap(a.__isset, b.__isset); +} + +bool ShowCompactRequest::operator==(const ShowCompactRequest & rhs) const +{ + if (__isset.id != rhs.__isset.id) + return false; + else if (__isset.id && !(id == rhs.id)) + return false; + if (__isset.poolName != rhs.__isset.poolName) + return false; + else if (__isset.poolName && !(poolName == rhs.poolName)) + return false; + if (__isset.dbName != rhs.__isset.dbName) + return false; + else if (__isset.dbName && !(dbName == rhs.dbName)) + return false; + if (__isset.tbName != rhs.__isset.tbName) + return false; + else if (__isset.tbName && !(tbName == rhs.tbName)) + return false; + if (__isset.partName != rhs.__isset.partName) + return false; + else if (__isset.partName && !(partName == rhs.partName)) + return false; + if (__isset.type != rhs.__isset.type) + return false; + else if (__isset.type && !(type == rhs.type)) + return false; + if (__isset.state != rhs.__isset.state) + return false; + else if (__isset.state && !(state == rhs.state)) + return false; + if (__isset.limit != rhs.__isset.limit) + return false; + else if (__isset.limit && !(limit == rhs.limit)) + return false; + if (__isset.order != rhs.__isset.order) + return false; + else if (__isset.order && !(order == rhs.order)) + return false; + return true; +} + +ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other1052) { + id = other1052.id; + poolName = other1052.poolName; + dbName = other1052.dbName; + tbName = other1052.tbName; + partName = other1052.partName; + type = other1052.type; + state = other1052.state; + limit = other1052.limit; + order = other1052.order; + __isset = other1052.__isset; +} +ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other1053) { + id = other1053.id; + poolName = other1053.poolName; + dbName = other1053.dbName; + tbName = other1053.tbName; + partName = other1053.partName; + type = other1053.type; + state = other1053.state; + limit = other1053.limit; + order = other1053.order; + __isset = other1053.__isset; + return *this; +} +void ShowCompactRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ShowCompactRequest("; + out << "id="; (__isset.id ? (out << to_string(id)) : (out << "")); + out << ", " << "poolName="; (__isset.poolName ? (out << to_string(poolName)) : (out << "")); + out << ", " << "dbName="; (__isset.dbName ? (out << to_string(dbName)) : (out << "")); + out << ", " << "tbName="; (__isset.tbName ? (out << to_string(tbName)) : (out << "")); + out << ", " << "partName="; (__isset.partName ? (out << to_string(partName)) : (out << "")); + out << ", " << "type="; (__isset.type ? (out << to_string(type)) : (out << "")); + out << ", " << "state="; (__isset.state ? (out << to_string(state)) : (out << "")); + out << ", " << "limit="; (__isset.limit ? (out << to_string(limit)) : (out << "")); + out << ", " << "order="; (__isset.order ? (out << to_string(order)) : (out << "")); + out << ")"; +} + + +ShowCompactResponseElement::~ShowCompactResponseElement() noexcept { +} + +ShowCompactResponseElement::ShowCompactResponseElement() : dbname(), + tablename(), + partitionname(), + type(static_cast(0)), + state(), + workerid(), + start(0), + runAs(), + hightestTxnId(0), + metaInfo(), + endTime(0), + hadoopJobId("None"), + id(0), + errorMessage(), + enqueueTime(0), + workerVersion(), + initiatorId(), + initiatorVersion(), + cleanerStart(0), + poolName(), + nextTxnId(0), + txnId(0), + commitTime(0), + hightestWriteId(0) { +} + +void ShowCompactResponseElement::__set_dbname(const std::string& val) { + this->dbname = val; +} + +void ShowCompactResponseElement::__set_tablename(const std::string& val) { + this->tablename = val; +} + +void ShowCompactResponseElement::__set_partitionname(const std::string& val) { + this->partitionname = val; +__isset.partitionname = true; +} + +void ShowCompactResponseElement::__set_type(const CompactionType::type val) { + this->type = val; +} + +void ShowCompactResponseElement::__set_state(const std::string& val) { + this->state = val; +} + +void ShowCompactResponseElement::__set_workerid(const std::string& val) { + this->workerid = val; +__isset.workerid = true; +} + +void ShowCompactResponseElement::__set_start(const int64_t val) { + this->start = val; +__isset.start = true; +} + +void ShowCompactResponseElement::__set_runAs(const std::string& val) { + this->runAs = val; +__isset.runAs = true; +} + +void ShowCompactResponseElement::__set_hightestTxnId(const int64_t val) { + this->hightestTxnId = val; +__isset.hightestTxnId = true; +} + +void ShowCompactResponseElement::__set_metaInfo(const std::string& val) { + this->metaInfo = val; +__isset.metaInfo = true; +} + +void ShowCompactResponseElement::__set_endTime(const int64_t val) { + this->endTime = val; +__isset.endTime = true; +} + +void ShowCompactResponseElement::__set_hadoopJobId(const std::string& val) { + this->hadoopJobId = val; +__isset.hadoopJobId = true; +} + +void ShowCompactResponseElement::__set_id(const int64_t val) { + this->id = val; +__isset.id = true; +} + +void ShowCompactResponseElement::__set_errorMessage(const std::string& val) { + this->errorMessage = val; +__isset.errorMessage = true; +} + +void ShowCompactResponseElement::__set_enqueueTime(const int64_t val) { + this->enqueueTime = val; +__isset.enqueueTime = true; +} + +void ShowCompactResponseElement::__set_workerVersion(const std::string& val) { + this->workerVersion = val; +__isset.workerVersion = true; +} + +void ShowCompactResponseElement::__set_initiatorId(const std::string& val) { + this->initiatorId = val; +__isset.initiatorId = true; +} + +void ShowCompactResponseElement::__set_initiatorVersion(const std::string& val) { + this->initiatorVersion = val; +__isset.initiatorVersion = true; +} + +void ShowCompactResponseElement::__set_cleanerStart(const int64_t val) { + this->cleanerStart = val; +__isset.cleanerStart = true; +} + +void ShowCompactResponseElement::__set_poolName(const std::string& val) { + this->poolName = val; +__isset.poolName = true; +} + +void ShowCompactResponseElement::__set_nextTxnId(const int64_t val) { + this->nextTxnId = val; +__isset.nextTxnId = true; +} + +void ShowCompactResponseElement::__set_txnId(const int64_t val) { + this->txnId = val; +__isset.txnId = true; +} + +void ShowCompactResponseElement::__set_commitTime(const int64_t val) { + this->commitTime = val; +__isset.commitTime = true; +} + +void ShowCompactResponseElement::__set_hightestWriteId(const int64_t val) { + this->hightestWriteId = val; +__isset.hightestWriteId = true; +} +std::ostream& operator<<(std::ostream& out, const ShowCompactResponseElement& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbname = false; + bool isset_tablename = false; + bool isset_type = false; + bool isset_state = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbname); + isset_dbname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tablename); + isset_tablename = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->partitionname); + this->__isset.partitionname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1054; + xfer += iprot->readI32(ecast1054); + this->type = static_cast(ecast1054); + isset_type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->state); + isset_state = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->workerid); + this->__isset.workerid = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->start); + this->__isset.start = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->runAs); + this->__isset.runAs = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->hightestTxnId); + this->__isset.hightestTxnId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->metaInfo); + this->__isset.metaInfo = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 11: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->endTime); + this->__isset.endTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 12: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->hadoopJobId); + this->__isset.hadoopJobId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 13: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->id); + this->__isset.id = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 14: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->errorMessage); + this->__isset.errorMessage = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 15: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->enqueueTime); + this->__isset.enqueueTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 16: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->workerVersion); + this->__isset.workerVersion = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 17: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->initiatorId); + this->__isset.initiatorId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 18: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->initiatorVersion); + this->__isset.initiatorVersion = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 19: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->cleanerStart); + this->__isset.cleanerStart = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 20: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->poolName); + this->__isset.poolName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 21: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->nextTxnId); + this->__isset.nextTxnId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 22: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnId); + this->__isset.txnId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 23: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->commitTime); + this->__isset.commitTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 24: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->hightestWriteId); + this->__isset.hightestWriteId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbname) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tablename) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_type) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_state) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ShowCompactResponseElement::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ShowCompactResponseElement"); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbname); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tablename", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tablename); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.partitionname) { + xfer += oprot->writeFieldBegin("partitionname", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->partitionname); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32(static_cast(this->type)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->state); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.workerid) { + xfer += oprot->writeFieldBegin("workerid", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->workerid); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.start) { + xfer += oprot->writeFieldBegin("start", ::apache::thrift::protocol::T_I64, 7); + xfer += oprot->writeI64(this->start); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.runAs) { + xfer += oprot->writeFieldBegin("runAs", ::apache::thrift::protocol::T_STRING, 8); + xfer += oprot->writeString(this->runAs); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.hightestTxnId) { + xfer += oprot->writeFieldBegin("hightestTxnId", ::apache::thrift::protocol::T_I64, 9); + xfer += oprot->writeI64(this->hightestTxnId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.metaInfo) { + xfer += oprot->writeFieldBegin("metaInfo", ::apache::thrift::protocol::T_STRING, 10); + xfer += oprot->writeString(this->metaInfo); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.endTime) { + xfer += oprot->writeFieldBegin("endTime", ::apache::thrift::protocol::T_I64, 11); + xfer += oprot->writeI64(this->endTime); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.hadoopJobId) { + xfer += oprot->writeFieldBegin("hadoopJobId", ::apache::thrift::protocol::T_STRING, 12); + xfer += oprot->writeString(this->hadoopJobId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.id) { + xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I64, 13); + xfer += oprot->writeI64(this->id); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.errorMessage) { + xfer += oprot->writeFieldBegin("errorMessage", ::apache::thrift::protocol::T_STRING, 14); + xfer += oprot->writeString(this->errorMessage); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.enqueueTime) { + xfer += oprot->writeFieldBegin("enqueueTime", ::apache::thrift::protocol::T_I64, 15); + xfer += oprot->writeI64(this->enqueueTime); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.workerVersion) { + xfer += oprot->writeFieldBegin("workerVersion", ::apache::thrift::protocol::T_STRING, 16); + xfer += oprot->writeString(this->workerVersion); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.initiatorId) { + xfer += oprot->writeFieldBegin("initiatorId", ::apache::thrift::protocol::T_STRING, 17); + xfer += oprot->writeString(this->initiatorId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.initiatorVersion) { + xfer += oprot->writeFieldBegin("initiatorVersion", ::apache::thrift::protocol::T_STRING, 18); + xfer += oprot->writeString(this->initiatorVersion); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.cleanerStart) { + xfer += oprot->writeFieldBegin("cleanerStart", ::apache::thrift::protocol::T_I64, 19); + xfer += oprot->writeI64(this->cleanerStart); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.poolName) { + xfer += oprot->writeFieldBegin("poolName", ::apache::thrift::protocol::T_STRING, 20); + xfer += oprot->writeString(this->poolName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.nextTxnId) { + xfer += oprot->writeFieldBegin("nextTxnId", ::apache::thrift::protocol::T_I64, 21); + xfer += oprot->writeI64(this->nextTxnId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.txnId) { + xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 22); + xfer += oprot->writeI64(this->txnId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.commitTime) { + xfer += oprot->writeFieldBegin("commitTime", ::apache::thrift::protocol::T_I64, 23); + xfer += oprot->writeI64(this->commitTime); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.hightestWriteId) { + xfer += oprot->writeFieldBegin("hightestWriteId", ::apache::thrift::protocol::T_I64, 24); + xfer += oprot->writeI64(this->hightestWriteId); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) noexcept { + using ::std::swap; + swap(a.dbname, b.dbname); + swap(a.tablename, b.tablename); + swap(a.partitionname, b.partitionname); + swap(a.type, b.type); + swap(a.state, b.state); + swap(a.workerid, b.workerid); + swap(a.start, b.start); + swap(a.runAs, b.runAs); + swap(a.hightestTxnId, b.hightestTxnId); + swap(a.metaInfo, b.metaInfo); + swap(a.endTime, b.endTime); + swap(a.hadoopJobId, b.hadoopJobId); + swap(a.id, b.id); + swap(a.errorMessage, b.errorMessage); + swap(a.enqueueTime, b.enqueueTime); + swap(a.workerVersion, b.workerVersion); + swap(a.initiatorId, b.initiatorId); + swap(a.initiatorVersion, b.initiatorVersion); + swap(a.cleanerStart, b.cleanerStart); + swap(a.poolName, b.poolName); + swap(a.nextTxnId, b.nextTxnId); + swap(a.txnId, b.txnId); + swap(a.commitTime, b.commitTime); + swap(a.hightestWriteId, b.hightestWriteId); + swap(a.__isset, b.__isset); +} + +bool ShowCompactResponseElement::operator==(const ShowCompactResponseElement & rhs) const +{ + if (!(dbname == rhs.dbname)) + return false; + if (!(tablename == rhs.tablename)) + return false; + if (__isset.partitionname != rhs.__isset.partitionname) + return false; + else if (__isset.partitionname && !(partitionname == rhs.partitionname)) + return false; + if (!(type == rhs.type)) + return false; + if (!(state == rhs.state)) + return false; + if (__isset.workerid != rhs.__isset.workerid) + return false; + else if (__isset.workerid && !(workerid == rhs.workerid)) + return false; + if (__isset.start != rhs.__isset.start) + return false; + else if (__isset.start && !(start == rhs.start)) + return false; + if (__isset.runAs != rhs.__isset.runAs) + return false; + else if (__isset.runAs && !(runAs == rhs.runAs)) + return false; + if (__isset.hightestTxnId != rhs.__isset.hightestTxnId) + return false; + else if (__isset.hightestTxnId && !(hightestTxnId == rhs.hightestTxnId)) + return false; + if (__isset.metaInfo != rhs.__isset.metaInfo) + return false; + else if (__isset.metaInfo && !(metaInfo == rhs.metaInfo)) + return false; + if (__isset.endTime != rhs.__isset.endTime) + return false; + else if (__isset.endTime && !(endTime == rhs.endTime)) + return false; + if (__isset.hadoopJobId != rhs.__isset.hadoopJobId) + return false; + else if (__isset.hadoopJobId && !(hadoopJobId == rhs.hadoopJobId)) + return false; + if (__isset.id != rhs.__isset.id) + return false; + else if (__isset.id && !(id == rhs.id)) + return false; + if (__isset.errorMessage != rhs.__isset.errorMessage) + return false; + else if (__isset.errorMessage && !(errorMessage == rhs.errorMessage)) + return false; + if (__isset.enqueueTime != rhs.__isset.enqueueTime) + return false; + else if (__isset.enqueueTime && !(enqueueTime == rhs.enqueueTime)) + return false; + if (__isset.workerVersion != rhs.__isset.workerVersion) + return false; + else if (__isset.workerVersion && !(workerVersion == rhs.workerVersion)) + return false; + if (__isset.initiatorId != rhs.__isset.initiatorId) + return false; + else if (__isset.initiatorId && !(initiatorId == rhs.initiatorId)) + return false; + if (__isset.initiatorVersion != rhs.__isset.initiatorVersion) + return false; + else if (__isset.initiatorVersion && !(initiatorVersion == rhs.initiatorVersion)) + return false; + if (__isset.cleanerStart != rhs.__isset.cleanerStart) + return false; + else if (__isset.cleanerStart && !(cleanerStart == rhs.cleanerStart)) + return false; + if (__isset.poolName != rhs.__isset.poolName) + return false; + else if (__isset.poolName && !(poolName == rhs.poolName)) + return false; + if (__isset.nextTxnId != rhs.__isset.nextTxnId) + return false; + else if (__isset.nextTxnId && !(nextTxnId == rhs.nextTxnId)) + return false; + if (__isset.txnId != rhs.__isset.txnId) + return false; + else if (__isset.txnId && !(txnId == rhs.txnId)) + return false; + if (__isset.commitTime != rhs.__isset.commitTime) + return false; + else if (__isset.commitTime && !(commitTime == rhs.commitTime)) + return false; + if (__isset.hightestWriteId != rhs.__isset.hightestWriteId) + return false; + else if (__isset.hightestWriteId && !(hightestWriteId == rhs.hightestWriteId)) + return false; + return true; +} + +ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other1055) { + dbname = other1055.dbname; + tablename = other1055.tablename; + partitionname = other1055.partitionname; + type = other1055.type; + state = other1055.state; + workerid = other1055.workerid; + start = other1055.start; + runAs = other1055.runAs; + hightestTxnId = other1055.hightestTxnId; + metaInfo = other1055.metaInfo; + endTime = other1055.endTime; + hadoopJobId = other1055.hadoopJobId; + id = other1055.id; + errorMessage = other1055.errorMessage; + enqueueTime = other1055.enqueueTime; + workerVersion = other1055.workerVersion; + initiatorId = other1055.initiatorId; + initiatorVersion = other1055.initiatorVersion; + cleanerStart = other1055.cleanerStart; + poolName = other1055.poolName; + nextTxnId = other1055.nextTxnId; + txnId = other1055.txnId; + commitTime = other1055.commitTime; + hightestWriteId = other1055.hightestWriteId; + __isset = other1055.__isset; +} +ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other1056) { + dbname = other1056.dbname; + tablename = other1056.tablename; + partitionname = other1056.partitionname; + type = other1056.type; + state = other1056.state; + workerid = other1056.workerid; + start = other1056.start; + runAs = other1056.runAs; + hightestTxnId = other1056.hightestTxnId; + metaInfo = other1056.metaInfo; + endTime = other1056.endTime; + hadoopJobId = other1056.hadoopJobId; + id = other1056.id; + errorMessage = other1056.errorMessage; + enqueueTime = other1056.enqueueTime; + workerVersion = other1056.workerVersion; + initiatorId = other1056.initiatorId; + initiatorVersion = other1056.initiatorVersion; + cleanerStart = other1056.cleanerStart; + poolName = other1056.poolName; + nextTxnId = other1056.nextTxnId; + txnId = other1056.txnId; + commitTime = other1056.commitTime; + hightestWriteId = other1056.hightestWriteId; + __isset = other1056.__isset; + return *this; +} +void ShowCompactResponseElement::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ShowCompactResponseElement("; + out << "dbname=" << to_string(dbname); + out << ", " << "tablename=" << to_string(tablename); + out << ", " << "partitionname="; (__isset.partitionname ? (out << to_string(partitionname)) : (out << "")); + out << ", " << "type=" << to_string(type); + out << ", " << "state=" << to_string(state); + out << ", " << "workerid="; (__isset.workerid ? (out << to_string(workerid)) : (out << "")); + out << ", " << "start="; (__isset.start ? (out << to_string(start)) : (out << "")); + out << ", " << "runAs="; (__isset.runAs ? (out << to_string(runAs)) : (out << "")); + out << ", " << "hightestTxnId="; (__isset.hightestTxnId ? (out << to_string(hightestTxnId)) : (out << "")); + out << ", " << "metaInfo="; (__isset.metaInfo ? (out << to_string(metaInfo)) : (out << "")); + out << ", " << "endTime="; (__isset.endTime ? (out << to_string(endTime)) : (out << "")); + out << ", " << "hadoopJobId="; (__isset.hadoopJobId ? (out << to_string(hadoopJobId)) : (out << "")); + out << ", " << "id="; (__isset.id ? (out << to_string(id)) : (out << "")); + out << ", " << "errorMessage="; (__isset.errorMessage ? (out << to_string(errorMessage)) : (out << "")); + out << ", " << "enqueueTime="; (__isset.enqueueTime ? (out << to_string(enqueueTime)) : (out << "")); + out << ", " << "workerVersion="; (__isset.workerVersion ? (out << to_string(workerVersion)) : (out << "")); + out << ", " << "initiatorId="; (__isset.initiatorId ? (out << to_string(initiatorId)) : (out << "")); + out << ", " << "initiatorVersion="; (__isset.initiatorVersion ? (out << to_string(initiatorVersion)) : (out << "")); + out << ", " << "cleanerStart="; (__isset.cleanerStart ? (out << to_string(cleanerStart)) : (out << "")); + out << ", " << "poolName="; (__isset.poolName ? (out << to_string(poolName)) : (out << "")); + out << ", " << "nextTxnId="; (__isset.nextTxnId ? (out << to_string(nextTxnId)) : (out << "")); + out << ", " << "txnId="; (__isset.txnId ? (out << to_string(txnId)) : (out << "")); + out << ", " << "commitTime="; (__isset.commitTime ? (out << to_string(commitTime)) : (out << "")); + out << ", " << "hightestWriteId="; (__isset.hightestWriteId ? (out << to_string(hightestWriteId)) : (out << "")); + out << ")"; +} + + +ShowCompactResponse::~ShowCompactResponse() noexcept { +} + +ShowCompactResponse::ShowCompactResponse() noexcept { +} + +void ShowCompactResponse::__set_compacts(const std::vector & val) { + this->compacts = val; +} +std::ostream& operator<<(std::ostream& out, const ShowCompactResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ShowCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_compacts = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->compacts.clear(); + uint32_t _size1057; + ::apache::thrift::protocol::TType _etype1060; + xfer += iprot->readListBegin(_etype1060, _size1057); + this->compacts.resize(_size1057); + uint32_t _i1061; + for (_i1061 = 0; _i1061 < _size1057; ++_i1061) + { + xfer += this->compacts[_i1061].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_compacts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_compacts) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ShowCompactResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ShowCompactResponse"); + + xfer += oprot->writeFieldBegin("compacts", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->compacts.size())); + std::vector ::const_iterator _iter1062; + for (_iter1062 = this->compacts.begin(); _iter1062 != this->compacts.end(); ++_iter1062) + { + xfer += (*_iter1062).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ShowCompactResponse &a, ShowCompactResponse &b) noexcept { + using ::std::swap; + swap(a.compacts, b.compacts); +} + +bool ShowCompactResponse::operator==(const ShowCompactResponse & rhs) const +{ + if (!(compacts == rhs.compacts)) + return false; + return true; +} + +ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other1063) { + compacts = other1063.compacts; +} +ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other1064) { + compacts = other1064.compacts; + return *this; +} +void ShowCompactResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ShowCompactResponse("; + out << "compacts=" << to_string(compacts); + out << ")"; +} + + +AbortCompactionRequest::~AbortCompactionRequest() noexcept { +} + +AbortCompactionRequest::AbortCompactionRequest() noexcept + : type(), + poolName() { +} + +void AbortCompactionRequest::__set_compactionIds(const std::vector & val) { + this->compactionIds = val; +} + +void AbortCompactionRequest::__set_type(const std::string& val) { + this->type = val; +__isset.type = true; +} + +void AbortCompactionRequest::__set_poolName(const std::string& val) { + this->poolName = val; +__isset.poolName = true; +} +std::ostream& operator<<(std::ostream& out, const AbortCompactionRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AbortCompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_compactionIds = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->compactionIds.clear(); + uint32_t _size1065; + ::apache::thrift::protocol::TType _etype1068; + xfer += iprot->readListBegin(_etype1068, _size1065); + this->compactionIds.resize(_size1065); + uint32_t _i1069; + for (_i1069 = 0; _i1069 < _size1065; ++_i1069) + { + xfer += iprot->readI64(this->compactionIds[_i1069]); + } + xfer += iprot->readListEnd(); + } + isset_compactionIds = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->type); + this->__isset.type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->poolName); + this->__isset.poolName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_compactionIds) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AbortCompactionRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AbortCompactionRequest"); + + xfer += oprot->writeFieldBegin("compactionIds", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->compactionIds.size())); + std::vector ::const_iterator _iter1070; + for (_iter1070 = this->compactionIds.begin(); _iter1070 != this->compactionIds.end(); ++_iter1070) + { + xfer += oprot->writeI64((*_iter1070)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.type) { + xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->type); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.poolName) { + xfer += oprot->writeFieldBegin("poolName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->poolName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AbortCompactionRequest &a, AbortCompactionRequest &b) noexcept { + using ::std::swap; + swap(a.compactionIds, b.compactionIds); + swap(a.type, b.type); + swap(a.poolName, b.poolName); + swap(a.__isset, b.__isset); +} + +bool AbortCompactionRequest::operator==(const AbortCompactionRequest & rhs) const +{ + if (!(compactionIds == rhs.compactionIds)) + return false; + if (__isset.type != rhs.__isset.type) + return false; + else if (__isset.type && !(type == rhs.type)) + return false; + if (__isset.poolName != rhs.__isset.poolName) + return false; + else if (__isset.poolName && !(poolName == rhs.poolName)) + return false; + return true; +} + +AbortCompactionRequest::AbortCompactionRequest(const AbortCompactionRequest& other1071) { + compactionIds = other1071.compactionIds; + type = other1071.type; + poolName = other1071.poolName; + __isset = other1071.__isset; +} +AbortCompactionRequest& AbortCompactionRequest::operator=(const AbortCompactionRequest& other1072) { + compactionIds = other1072.compactionIds; + type = other1072.type; + poolName = other1072.poolName; + __isset = other1072.__isset; + return *this; +} +void AbortCompactionRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AbortCompactionRequest("; + out << "compactionIds=" << to_string(compactionIds); + out << ", " << "type="; (__isset.type ? (out << to_string(type)) : (out << "")); + out << ", " << "poolName="; (__isset.poolName ? (out << to_string(poolName)) : (out << "")); + out << ")"; +} + + +AbortCompactionResponseElement::~AbortCompactionResponseElement() noexcept { +} + +AbortCompactionResponseElement::AbortCompactionResponseElement() noexcept + : compactionId(0), + status(), + message() { +} + +void AbortCompactionResponseElement::__set_compactionId(const int64_t val) { + this->compactionId = val; +} + +void AbortCompactionResponseElement::__set_status(const std::string& val) { + this->status = val; +__isset.status = true; +} + +void AbortCompactionResponseElement::__set_message(const std::string& val) { + this->message = val; +__isset.message = true; +} +std::ostream& operator<<(std::ostream& out, const AbortCompactionResponseElement& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AbortCompactionResponseElement::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_compactionId = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->compactionId); + isset_compactionId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->status); + this->__isset.status = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_compactionId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AbortCompactionResponseElement::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AbortCompactionResponseElement"); + + xfer += oprot->writeFieldBegin("compactionId", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->compactionId); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.status) { + xfer += oprot->writeFieldBegin("status", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->status); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.message) { + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AbortCompactionResponseElement &a, AbortCompactionResponseElement &b) noexcept { + using ::std::swap; + swap(a.compactionId, b.compactionId); + swap(a.status, b.status); + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +bool AbortCompactionResponseElement::operator==(const AbortCompactionResponseElement & rhs) const +{ + if (!(compactionId == rhs.compactionId)) + return false; + if (__isset.status != rhs.__isset.status) + return false; + else if (__isset.status && !(status == rhs.status)) + return false; + if (__isset.message != rhs.__isset.message) + return false; + else if (__isset.message && !(message == rhs.message)) + return false; + return true; +} + +AbortCompactionResponseElement::AbortCompactionResponseElement(const AbortCompactionResponseElement& other1073) { + compactionId = other1073.compactionId; + status = other1073.status; + message = other1073.message; + __isset = other1073.__isset; +} +AbortCompactionResponseElement& AbortCompactionResponseElement::operator=(const AbortCompactionResponseElement& other1074) { + compactionId = other1074.compactionId; + status = other1074.status; + message = other1074.message; + __isset = other1074.__isset; + return *this; +} +void AbortCompactionResponseElement::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AbortCompactionResponseElement("; + out << "compactionId=" << to_string(compactionId); + out << ", " << "status="; (__isset.status ? (out << to_string(status)) : (out << "")); + out << ", " << "message="; (__isset.message ? (out << to_string(message)) : (out << "")); + out << ")"; +} + + +AbortCompactResponse::~AbortCompactResponse() noexcept { +} + +AbortCompactResponse::AbortCompactResponse() noexcept { +} + +void AbortCompactResponse::__set_abortedcompacts(const std::map & val) { + this->abortedcompacts = val; +} +std::ostream& operator<<(std::ostream& out, const AbortCompactResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AbortCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_abortedcompacts = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->abortedcompacts.clear(); + uint32_t _size1075; + ::apache::thrift::protocol::TType _ktype1076; + ::apache::thrift::protocol::TType _vtype1077; + xfer += iprot->readMapBegin(_ktype1076, _vtype1077, _size1075); + uint32_t _i1079; + for (_i1079 = 0; _i1079 < _size1075; ++_i1079) + { + int64_t _key1080; + xfer += iprot->readI64(_key1080); + AbortCompactionResponseElement& _val1081 = this->abortedcompacts[_key1080]; + xfer += _val1081.read(iprot); + } + xfer += iprot->readMapEnd(); + } + isset_abortedcompacts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_abortedcompacts) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AbortCompactResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AbortCompactResponse"); + + xfer += oprot->writeFieldBegin("abortedcompacts", ::apache::thrift::protocol::T_MAP, 1); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I64, ::apache::thrift::protocol::T_STRUCT, static_cast(this->abortedcompacts.size())); + std::map ::const_iterator _iter1082; + for (_iter1082 = this->abortedcompacts.begin(); _iter1082 != this->abortedcompacts.end(); ++_iter1082) + { + xfer += oprot->writeI64(_iter1082->first); + xfer += _iter1082->second.write(oprot); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AbortCompactResponse &a, AbortCompactResponse &b) noexcept { + using ::std::swap; + swap(a.abortedcompacts, b.abortedcompacts); +} + +bool AbortCompactResponse::operator==(const AbortCompactResponse & rhs) const +{ + if (!(abortedcompacts == rhs.abortedcompacts)) + return false; + return true; +} + +AbortCompactResponse::AbortCompactResponse(const AbortCompactResponse& other1083) { + abortedcompacts = other1083.abortedcompacts; +} +AbortCompactResponse& AbortCompactResponse::operator=(const AbortCompactResponse& other1084) { + abortedcompacts = other1084.abortedcompacts; + return *this; +} +void AbortCompactResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AbortCompactResponse("; + out << "abortedcompacts=" << to_string(abortedcompacts); + out << ")"; +} + + +GetLatestCommittedCompactionInfoRequest::~GetLatestCommittedCompactionInfoRequest() noexcept { +} + +GetLatestCommittedCompactionInfoRequest::GetLatestCommittedCompactionInfoRequest() noexcept + : dbname(), + tablename(), + lastCompactionId(0) { +} + +void GetLatestCommittedCompactionInfoRequest::__set_dbname(const std::string& val) { + this->dbname = val; +} + +void GetLatestCommittedCompactionInfoRequest::__set_tablename(const std::string& val) { + this->tablename = val; +} + +void GetLatestCommittedCompactionInfoRequest::__set_partitionnames(const std::vector & val) { + this->partitionnames = val; +__isset.partitionnames = true; +} + +void GetLatestCommittedCompactionInfoRequest::__set_lastCompactionId(const int64_t val) { + this->lastCompactionId = val; +__isset.lastCompactionId = true; +} +std::ostream& operator<<(std::ostream& out, const GetLatestCommittedCompactionInfoRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetLatestCommittedCompactionInfoRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbname = false; + bool isset_tablename = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbname); + isset_dbname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tablename); + isset_tablename = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitionnames.clear(); + uint32_t _size1085; + ::apache::thrift::protocol::TType _etype1088; + xfer += iprot->readListBegin(_etype1088, _size1085); + this->partitionnames.resize(_size1085); + uint32_t _i1089; + for (_i1089 = 0; _i1089 < _size1085; ++_i1089) + { + xfer += iprot->readString(this->partitionnames[_i1089]); + } + xfer += iprot->readListEnd(); + } + this->__isset.partitionnames = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->lastCompactionId); + this->__isset.lastCompactionId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbname) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tablename) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetLatestCommittedCompactionInfoRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetLatestCommittedCompactionInfoRequest"); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbname); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tablename", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tablename); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.partitionnames) { + xfer += oprot->writeFieldBegin("partitionnames", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionnames.size())); + std::vector ::const_iterator _iter1090; + for (_iter1090 = this->partitionnames.begin(); _iter1090 != this->partitionnames.end(); ++_iter1090) + { + xfer += oprot->writeString((*_iter1090)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.lastCompactionId) { + xfer += oprot->writeFieldBegin("lastCompactionId", ::apache::thrift::protocol::T_I64, 4); + xfer += oprot->writeI64(this->lastCompactionId); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetLatestCommittedCompactionInfoRequest &a, GetLatestCommittedCompactionInfoRequest &b) noexcept { + using ::std::swap; + swap(a.dbname, b.dbname); + swap(a.tablename, b.tablename); + swap(a.partitionnames, b.partitionnames); + swap(a.lastCompactionId, b.lastCompactionId); + swap(a.__isset, b.__isset); +} + +bool GetLatestCommittedCompactionInfoRequest::operator==(const GetLatestCommittedCompactionInfoRequest & rhs) const +{ + if (!(dbname == rhs.dbname)) + return false; + if (!(tablename == rhs.tablename)) + return false; + if (__isset.partitionnames != rhs.__isset.partitionnames) + return false; + else if (__isset.partitionnames && !(partitionnames == rhs.partitionnames)) + return false; + if (__isset.lastCompactionId != rhs.__isset.lastCompactionId) + return false; + else if (__isset.lastCompactionId && !(lastCompactionId == rhs.lastCompactionId)) + return false; + return true; +} + +GetLatestCommittedCompactionInfoRequest::GetLatestCommittedCompactionInfoRequest(const GetLatestCommittedCompactionInfoRequest& other1091) { + dbname = other1091.dbname; + tablename = other1091.tablename; + partitionnames = other1091.partitionnames; + lastCompactionId = other1091.lastCompactionId; + __isset = other1091.__isset; +} +GetLatestCommittedCompactionInfoRequest& GetLatestCommittedCompactionInfoRequest::operator=(const GetLatestCommittedCompactionInfoRequest& other1092) { + dbname = other1092.dbname; + tablename = other1092.tablename; + partitionnames = other1092.partitionnames; + lastCompactionId = other1092.lastCompactionId; + __isset = other1092.__isset; + return *this; +} +void GetLatestCommittedCompactionInfoRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetLatestCommittedCompactionInfoRequest("; + out << "dbname=" << to_string(dbname); + out << ", " << "tablename=" << to_string(tablename); + out << ", " << "partitionnames="; (__isset.partitionnames ? (out << to_string(partitionnames)) : (out << "")); + out << ", " << "lastCompactionId="; (__isset.lastCompactionId ? (out << to_string(lastCompactionId)) : (out << "")); + out << ")"; +} + + +GetLatestCommittedCompactionInfoResponse::~GetLatestCommittedCompactionInfoResponse() noexcept { +} + +GetLatestCommittedCompactionInfoResponse::GetLatestCommittedCompactionInfoResponse() noexcept { +} + +void GetLatestCommittedCompactionInfoResponse::__set_compactions(const std::vector & val) { + this->compactions = val; +} +std::ostream& operator<<(std::ostream& out, const GetLatestCommittedCompactionInfoResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetLatestCommittedCompactionInfoResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_compactions = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->compactions.clear(); + uint32_t _size1093; + ::apache::thrift::protocol::TType _etype1096; + xfer += iprot->readListBegin(_etype1096, _size1093); + this->compactions.resize(_size1093); + uint32_t _i1097; + for (_i1097 = 0; _i1097 < _size1093; ++_i1097) + { + xfer += this->compactions[_i1097].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_compactions = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_compactions) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetLatestCommittedCompactionInfoResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetLatestCommittedCompactionInfoResponse"); + + xfer += oprot->writeFieldBegin("compactions", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->compactions.size())); + std::vector ::const_iterator _iter1098; + for (_iter1098 = this->compactions.begin(); _iter1098 != this->compactions.end(); ++_iter1098) + { + xfer += (*_iter1098).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetLatestCommittedCompactionInfoResponse &a, GetLatestCommittedCompactionInfoResponse &b) noexcept { + using ::std::swap; + swap(a.compactions, b.compactions); +} + +bool GetLatestCommittedCompactionInfoResponse::operator==(const GetLatestCommittedCompactionInfoResponse & rhs) const +{ + if (!(compactions == rhs.compactions)) + return false; + return true; +} + +GetLatestCommittedCompactionInfoResponse::GetLatestCommittedCompactionInfoResponse(const GetLatestCommittedCompactionInfoResponse& other1099) { + compactions = other1099.compactions; +} +GetLatestCommittedCompactionInfoResponse& GetLatestCommittedCompactionInfoResponse::operator=(const GetLatestCommittedCompactionInfoResponse& other1100) { + compactions = other1100.compactions; + return *this; +} +void GetLatestCommittedCompactionInfoResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetLatestCommittedCompactionInfoResponse("; + out << "compactions=" << to_string(compactions); + out << ")"; +} + + +FindNextCompactRequest::~FindNextCompactRequest() noexcept { +} + +FindNextCompactRequest::FindNextCompactRequest() noexcept + : workerId(), + workerVersion(), + poolName() { +} + +void FindNextCompactRequest::__set_workerId(const std::string& val) { + this->workerId = val; +__isset.workerId = true; +} + +void FindNextCompactRequest::__set_workerVersion(const std::string& val) { + this->workerVersion = val; +__isset.workerVersion = true; +} + +void FindNextCompactRequest::__set_poolName(const std::string& val) { + this->poolName = val; +__isset.poolName = true; +} +std::ostream& operator<<(std::ostream& out, const FindNextCompactRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t FindNextCompactRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->workerId); + this->__isset.workerId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->workerVersion); + this->__isset.workerVersion = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->poolName); + this->__isset.poolName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FindNextCompactRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FindNextCompactRequest"); + + if (this->__isset.workerId) { + xfer += oprot->writeFieldBegin("workerId", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->workerId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.workerVersion) { + xfer += oprot->writeFieldBegin("workerVersion", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->workerVersion); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.poolName) { + xfer += oprot->writeFieldBegin("poolName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->poolName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(FindNextCompactRequest &a, FindNextCompactRequest &b) noexcept { + using ::std::swap; + swap(a.workerId, b.workerId); + swap(a.workerVersion, b.workerVersion); + swap(a.poolName, b.poolName); + swap(a.__isset, b.__isset); +} + +bool FindNextCompactRequest::operator==(const FindNextCompactRequest & rhs) const +{ + if (__isset.workerId != rhs.__isset.workerId) + return false; + else if (__isset.workerId && !(workerId == rhs.workerId)) + return false; + if (__isset.workerVersion != rhs.__isset.workerVersion) + return false; + else if (__isset.workerVersion && !(workerVersion == rhs.workerVersion)) + return false; + if (__isset.poolName != rhs.__isset.poolName) + return false; + else if (__isset.poolName && !(poolName == rhs.poolName)) + return false; + return true; +} + +FindNextCompactRequest::FindNextCompactRequest(const FindNextCompactRequest& other1101) { + workerId = other1101.workerId; + workerVersion = other1101.workerVersion; + poolName = other1101.poolName; + __isset = other1101.__isset; +} +FindNextCompactRequest& FindNextCompactRequest::operator=(const FindNextCompactRequest& other1102) { + workerId = other1102.workerId; + workerVersion = other1102.workerVersion; + poolName = other1102.poolName; + __isset = other1102.__isset; + return *this; +} +void FindNextCompactRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "FindNextCompactRequest("; + out << "workerId="; (__isset.workerId ? (out << to_string(workerId)) : (out << "")); + out << ", " << "workerVersion="; (__isset.workerVersion ? (out << to_string(workerVersion)) : (out << "")); + out << ", " << "poolName="; (__isset.poolName ? (out << to_string(poolName)) : (out << "")); + out << ")"; +} + + +AddDynamicPartitions::~AddDynamicPartitions() noexcept { +} + +AddDynamicPartitions::AddDynamicPartitions() noexcept + : txnid(0), + writeid(0), + dbname(), + tablename(), + operationType(static_cast(5)) { +} + +void AddDynamicPartitions::__set_txnid(const int64_t val) { + this->txnid = val; +} + +void AddDynamicPartitions::__set_writeid(const int64_t val) { + this->writeid = val; +} + +void AddDynamicPartitions::__set_dbname(const std::string& val) { + this->dbname = val; +} + +void AddDynamicPartitions::__set_tablename(const std::string& val) { + this->tablename = val; +} + +void AddDynamicPartitions::__set_partitionnames(const std::vector & val) { + this->partitionnames = val; +} + +void AddDynamicPartitions::__set_operationType(const DataOperationType::type val) { + this->operationType = val; +__isset.operationType = true; +} +std::ostream& operator<<(std::ostream& out, const AddDynamicPartitions& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_txnid = false; + bool isset_writeid = false; + bool isset_dbname = false; + bool isset_tablename = false; + bool isset_partitionnames = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnid); + isset_txnid = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->writeid); + isset_writeid = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbname); + isset_dbname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tablename); + isset_tablename = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitionnames.clear(); + uint32_t _size1103; + ::apache::thrift::protocol::TType _etype1106; + xfer += iprot->readListBegin(_etype1106, _size1103); + this->partitionnames.resize(_size1103); + uint32_t _i1107; + for (_i1107 = 0; _i1107 < _size1103; ++_i1107) + { + xfer += iprot->readString(this->partitionnames[_i1107]); + } + xfer += iprot->readListEnd(); + } + isset_partitionnames = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1108; + xfer += iprot->readI32(ecast1108); + this->operationType = static_cast(ecast1108); + this->__isset.operationType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_txnid) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_writeid) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_dbname) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tablename) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_partitionnames) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AddDynamicPartitions::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AddDynamicPartitions"); + + xfer += oprot->writeFieldBegin("txnid", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->txnid); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("writeid", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->writeid); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->dbname); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tablename", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->tablename); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("partitionnames", ::apache::thrift::protocol::T_LIST, 5); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionnames.size())); + std::vector ::const_iterator _iter1109; + for (_iter1109 = this->partitionnames.begin(); _iter1109 != this->partitionnames.end(); ++_iter1109) + { + xfer += oprot->writeString((*_iter1109)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.operationType) { + xfer += oprot->writeFieldBegin("operationType", ::apache::thrift::protocol::T_I32, 6); + xfer += oprot->writeI32(static_cast(this->operationType)); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) noexcept { + using ::std::swap; + swap(a.txnid, b.txnid); + swap(a.writeid, b.writeid); + swap(a.dbname, b.dbname); + swap(a.tablename, b.tablename); + swap(a.partitionnames, b.partitionnames); + swap(a.operationType, b.operationType); + swap(a.__isset, b.__isset); +} + +bool AddDynamicPartitions::operator==(const AddDynamicPartitions & rhs) const +{ + if (!(txnid == rhs.txnid)) + return false; + if (!(writeid == rhs.writeid)) + return false; + if (!(dbname == rhs.dbname)) + return false; + if (!(tablename == rhs.tablename)) + return false; + if (!(partitionnames == rhs.partitionnames)) + return false; + if (__isset.operationType != rhs.__isset.operationType) + return false; + else if (__isset.operationType && !(operationType == rhs.operationType)) + return false; + return true; +} + +AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other1110) { + txnid = other1110.txnid; + writeid = other1110.writeid; + dbname = other1110.dbname; + tablename = other1110.tablename; + partitionnames = other1110.partitionnames; + operationType = other1110.operationType; + __isset = other1110.__isset; +} +AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other1111) { + txnid = other1111.txnid; + writeid = other1111.writeid; + dbname = other1111.dbname; + tablename = other1111.tablename; + partitionnames = other1111.partitionnames; + operationType = other1111.operationType; + __isset = other1111.__isset; + return *this; +} +void AddDynamicPartitions::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AddDynamicPartitions("; + out << "txnid=" << to_string(txnid); + out << ", " << "writeid=" << to_string(writeid); + out << ", " << "dbname=" << to_string(dbname); + out << ", " << "tablename=" << to_string(tablename); + out << ", " << "partitionnames=" << to_string(partitionnames); + out << ", " << "operationType="; (__isset.operationType ? (out << to_string(operationType)) : (out << "")); + out << ")"; +} + + +BasicTxnInfo::~BasicTxnInfo() noexcept { +} + +BasicTxnInfo::BasicTxnInfo() noexcept + : isnull(0), + time(0), + txnid(0), + dbname(), + tablename(), + partitionname() { +} + +void BasicTxnInfo::__set_isnull(const bool val) { + this->isnull = val; +} + +void BasicTxnInfo::__set_time(const int64_t val) { + this->time = val; +__isset.time = true; +} + +void BasicTxnInfo::__set_txnid(const int64_t val) { + this->txnid = val; +__isset.txnid = true; +} + +void BasicTxnInfo::__set_dbname(const std::string& val) { + this->dbname = val; +__isset.dbname = true; +} + +void BasicTxnInfo::__set_tablename(const std::string& val) { + this->tablename = val; +__isset.tablename = true; +} + +void BasicTxnInfo::__set_partitionname(const std::string& val) { + this->partitionname = val; +__isset.partitionname = true; +} +std::ostream& operator<<(std::ostream& out, const BasicTxnInfo& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t BasicTxnInfo::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_isnull = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isnull); + isset_isnull = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->time); + this->__isset.time = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnid); + this->__isset.txnid = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbname); + this->__isset.dbname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tablename); + this->__isset.tablename = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->partitionname); + this->__isset.partitionname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_isnull) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t BasicTxnInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("BasicTxnInfo"); + + xfer += oprot->writeFieldBegin("isnull", ::apache::thrift::protocol::T_BOOL, 1); + xfer += oprot->writeBool(this->isnull); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.time) { + xfer += oprot->writeFieldBegin("time", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->time); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.txnid) { + xfer += oprot->writeFieldBegin("txnid", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->txnid); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.dbname) { + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->dbname); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.tablename) { + xfer += oprot->writeFieldBegin("tablename", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->tablename); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.partitionname) { + xfer += oprot->writeFieldBegin("partitionname", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->partitionname); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(BasicTxnInfo &a, BasicTxnInfo &b) noexcept { + using ::std::swap; + swap(a.isnull, b.isnull); + swap(a.time, b.time); + swap(a.txnid, b.txnid); + swap(a.dbname, b.dbname); + swap(a.tablename, b.tablename); + swap(a.partitionname, b.partitionname); + swap(a.__isset, b.__isset); +} + +bool BasicTxnInfo::operator==(const BasicTxnInfo & rhs) const +{ + if (!(isnull == rhs.isnull)) + return false; + if (__isset.time != rhs.__isset.time) + return false; + else if (__isset.time && !(time == rhs.time)) + return false; + if (__isset.txnid != rhs.__isset.txnid) + return false; + else if (__isset.txnid && !(txnid == rhs.txnid)) + return false; + if (__isset.dbname != rhs.__isset.dbname) + return false; + else if (__isset.dbname && !(dbname == rhs.dbname)) + return false; + if (__isset.tablename != rhs.__isset.tablename) + return false; + else if (__isset.tablename && !(tablename == rhs.tablename)) + return false; + if (__isset.partitionname != rhs.__isset.partitionname) + return false; + else if (__isset.partitionname && !(partitionname == rhs.partitionname)) + return false; + return true; +} + +BasicTxnInfo::BasicTxnInfo(const BasicTxnInfo& other1112) { + isnull = other1112.isnull; + time = other1112.time; + txnid = other1112.txnid; + dbname = other1112.dbname; + tablename = other1112.tablename; + partitionname = other1112.partitionname; + __isset = other1112.__isset; +} +BasicTxnInfo& BasicTxnInfo::operator=(const BasicTxnInfo& other1113) { + isnull = other1113.isnull; + time = other1113.time; + txnid = other1113.txnid; + dbname = other1113.dbname; + tablename = other1113.tablename; + partitionname = other1113.partitionname; + __isset = other1113.__isset; + return *this; +} +void BasicTxnInfo::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "BasicTxnInfo("; + out << "isnull=" << to_string(isnull); + out << ", " << "time="; (__isset.time ? (out << to_string(time)) : (out << "")); + out << ", " << "txnid="; (__isset.txnid ? (out << to_string(txnid)) : (out << "")); + out << ", " << "dbname="; (__isset.dbname ? (out << to_string(dbname)) : (out << "")); + out << ", " << "tablename="; (__isset.tablename ? (out << to_string(tablename)) : (out << "")); + out << ", " << "partitionname="; (__isset.partitionname ? (out << to_string(partitionname)) : (out << "")); + out << ")"; +} + + +NotificationEventRequest::~NotificationEventRequest() noexcept { +} + +NotificationEventRequest::NotificationEventRequest() noexcept + : lastEvent(0), + maxEvents(0), + catName(), + dbName() { +} + +void NotificationEventRequest::__set_lastEvent(const int64_t val) { + this->lastEvent = val; +} + +void NotificationEventRequest::__set_maxEvents(const int32_t val) { + this->maxEvents = val; +__isset.maxEvents = true; +} + +void NotificationEventRequest::__set_eventTypeSkipList(const std::vector & val) { + this->eventTypeSkipList = val; +__isset.eventTypeSkipList = true; +} + +void NotificationEventRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void NotificationEventRequest::__set_dbName(const std::string& val) { + this->dbName = val; +__isset.dbName = true; +} + +void NotificationEventRequest::__set_tableNames(const std::vector & val) { + this->tableNames = val; +__isset.tableNames = true; +} +std::ostream& operator<<(std::ostream& out, const NotificationEventRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t NotificationEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_lastEvent = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->lastEvent); + isset_lastEvent = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->maxEvents); + this->__isset.maxEvents = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->eventTypeSkipList.clear(); + uint32_t _size1114; + ::apache::thrift::protocol::TType _etype1117; + xfer += iprot->readListBegin(_etype1117, _size1114); + this->eventTypeSkipList.resize(_size1114); + uint32_t _i1118; + for (_i1118 = 0; _i1118 < _size1114; ++_i1118) + { + xfer += iprot->readString(this->eventTypeSkipList[_i1118]); + } + xfer += iprot->readListEnd(); + } + this->__isset.eventTypeSkipList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->tableNames.clear(); + uint32_t _size1119; + ::apache::thrift::protocol::TType _etype1122; + xfer += iprot->readListBegin(_etype1122, _size1119); + this->tableNames.resize(_size1119); + uint32_t _i1123; + for (_i1123 = 0; _i1123 < _size1119; ++_i1123) + { + xfer += iprot->readString(this->tableNames[_i1123]); + } + xfer += iprot->readListEnd(); + } + this->__isset.tableNames = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_lastEvent) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t NotificationEventRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("NotificationEventRequest"); + + xfer += oprot->writeFieldBegin("lastEvent", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->lastEvent); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.maxEvents) { + xfer += oprot->writeFieldBegin("maxEvents", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(this->maxEvents); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.eventTypeSkipList) { + xfer += oprot->writeFieldBegin("eventTypeSkipList", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->eventTypeSkipList.size())); + std::vector ::const_iterator _iter1124; + for (_iter1124 = this->eventTypeSkipList.begin(); _iter1124 != this->eventTypeSkipList.end(); ++_iter1124) + { + xfer += oprot->writeString((*_iter1124)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.dbName) { + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.tableNames) { + xfer += oprot->writeFieldBegin("tableNames", ::apache::thrift::protocol::T_LIST, 6); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tableNames.size())); + std::vector ::const_iterator _iter1125; + for (_iter1125 = this->tableNames.begin(); _iter1125 != this->tableNames.end(); ++_iter1125) + { + xfer += oprot->writeString((*_iter1125)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(NotificationEventRequest &a, NotificationEventRequest &b) noexcept { + using ::std::swap; + swap(a.lastEvent, b.lastEvent); + swap(a.maxEvents, b.maxEvents); + swap(a.eventTypeSkipList, b.eventTypeSkipList); + swap(a.catName, b.catName); + swap(a.dbName, b.dbName); + swap(a.tableNames, b.tableNames); + swap(a.__isset, b.__isset); +} + +bool NotificationEventRequest::operator==(const NotificationEventRequest & rhs) const +{ + if (!(lastEvent == rhs.lastEvent)) + return false; + if (__isset.maxEvents != rhs.__isset.maxEvents) + return false; + else if (__isset.maxEvents && !(maxEvents == rhs.maxEvents)) + return false; + if (__isset.eventTypeSkipList != rhs.__isset.eventTypeSkipList) + return false; + else if (__isset.eventTypeSkipList && !(eventTypeSkipList == rhs.eventTypeSkipList)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (__isset.dbName != rhs.__isset.dbName) + return false; + else if (__isset.dbName && !(dbName == rhs.dbName)) + return false; + if (__isset.tableNames != rhs.__isset.tableNames) + return false; + else if (__isset.tableNames && !(tableNames == rhs.tableNames)) + return false; + return true; +} + +NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other1126) { + lastEvent = other1126.lastEvent; + maxEvents = other1126.maxEvents; + eventTypeSkipList = other1126.eventTypeSkipList; + catName = other1126.catName; + dbName = other1126.dbName; + tableNames = other1126.tableNames; + __isset = other1126.__isset; +} +NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other1127) { + lastEvent = other1127.lastEvent; + maxEvents = other1127.maxEvents; + eventTypeSkipList = other1127.eventTypeSkipList; + catName = other1127.catName; + dbName = other1127.dbName; + tableNames = other1127.tableNames; + __isset = other1127.__isset; + return *this; +} +void NotificationEventRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "NotificationEventRequest("; + out << "lastEvent=" << to_string(lastEvent); + out << ", " << "maxEvents="; (__isset.maxEvents ? (out << to_string(maxEvents)) : (out << "")); + out << ", " << "eventTypeSkipList="; (__isset.eventTypeSkipList ? (out << to_string(eventTypeSkipList)) : (out << "")); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "dbName="; (__isset.dbName ? (out << to_string(dbName)) : (out << "")); + out << ", " << "tableNames="; (__isset.tableNames ? (out << to_string(tableNames)) : (out << "")); + out << ")"; +} + + +NotificationEvent::~NotificationEvent() noexcept { +} + +NotificationEvent::NotificationEvent() noexcept + : eventId(0), + eventTime(0), + eventType(), + dbName(), + tableName(), + message(), + messageFormat(), + catName() { +} + +void NotificationEvent::__set_eventId(const int64_t val) { + this->eventId = val; +} + +void NotificationEvent::__set_eventTime(const int32_t val) { + this->eventTime = val; +} + +void NotificationEvent::__set_eventType(const std::string& val) { + this->eventType = val; +} + +void NotificationEvent::__set_dbName(const std::string& val) { + this->dbName = val; +__isset.dbName = true; +} + +void NotificationEvent::__set_tableName(const std::string& val) { + this->tableName = val; +__isset.tableName = true; +} + +void NotificationEvent::__set_message(const std::string& val) { + this->message = val; +} + +void NotificationEvent::__set_messageFormat(const std::string& val) { + this->messageFormat = val; +__isset.messageFormat = true; +} + +void NotificationEvent::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} +std::ostream& operator<<(std::ostream& out, const NotificationEvent& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t NotificationEvent::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_eventId = false; + bool isset_eventTime = false; + bool isset_eventType = false; + bool isset_message = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->eventId); + isset_eventId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->eventTime); + isset_eventTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->eventType); + isset_eventType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + this->__isset.tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->message); + isset_message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->messageFormat); + this->__isset.messageFormat = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_eventId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_eventTime) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_eventType) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_message) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t NotificationEvent::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("NotificationEvent"); + + xfer += oprot->writeFieldBegin("eventId", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->eventId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("eventTime", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(this->eventTime); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("eventType", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->eventType); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.dbName) { + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.tableName) { + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.messageFormat) { + xfer += oprot->writeFieldBegin("messageFormat", ::apache::thrift::protocol::T_STRING, 7); + xfer += oprot->writeString(this->messageFormat); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 8); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(NotificationEvent &a, NotificationEvent &b) noexcept { + using ::std::swap; + swap(a.eventId, b.eventId); + swap(a.eventTime, b.eventTime); + swap(a.eventType, b.eventType); + swap(a.dbName, b.dbName); + swap(a.tableName, b.tableName); + swap(a.message, b.message); + swap(a.messageFormat, b.messageFormat); + swap(a.catName, b.catName); + swap(a.__isset, b.__isset); +} + +bool NotificationEvent::operator==(const NotificationEvent & rhs) const +{ + if (!(eventId == rhs.eventId)) + return false; + if (!(eventTime == rhs.eventTime)) + return false; + if (!(eventType == rhs.eventType)) + return false; + if (__isset.dbName != rhs.__isset.dbName) + return false; + else if (__isset.dbName && !(dbName == rhs.dbName)) + return false; + if (__isset.tableName != rhs.__isset.tableName) + return false; + else if (__isset.tableName && !(tableName == rhs.tableName)) + return false; + if (!(message == rhs.message)) + return false; + if (__isset.messageFormat != rhs.__isset.messageFormat) + return false; + else if (__isset.messageFormat && !(messageFormat == rhs.messageFormat)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + return true; +} + +NotificationEvent::NotificationEvent(const NotificationEvent& other1128) { + eventId = other1128.eventId; + eventTime = other1128.eventTime; + eventType = other1128.eventType; + dbName = other1128.dbName; + tableName = other1128.tableName; + message = other1128.message; + messageFormat = other1128.messageFormat; + catName = other1128.catName; + __isset = other1128.__isset; +} +NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other1129) { + eventId = other1129.eventId; + eventTime = other1129.eventTime; + eventType = other1129.eventType; + dbName = other1129.dbName; + tableName = other1129.tableName; + message = other1129.message; + messageFormat = other1129.messageFormat; + catName = other1129.catName; + __isset = other1129.__isset; + return *this; +} +void NotificationEvent::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "NotificationEvent("; + out << "eventId=" << to_string(eventId); + out << ", " << "eventTime=" << to_string(eventTime); + out << ", " << "eventType=" << to_string(eventType); + out << ", " << "dbName="; (__isset.dbName ? (out << to_string(dbName)) : (out << "")); + out << ", " << "tableName="; (__isset.tableName ? (out << to_string(tableName)) : (out << "")); + out << ", " << "message=" << to_string(message); + out << ", " << "messageFormat="; (__isset.messageFormat ? (out << to_string(messageFormat)) : (out << "")); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ")"; +} + + +NotificationEventResponse::~NotificationEventResponse() noexcept { +} + +NotificationEventResponse::NotificationEventResponse() noexcept { +} + +void NotificationEventResponse::__set_events(const std::vector & val) { + this->events = val; +} +std::ostream& operator<<(std::ostream& out, const NotificationEventResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t NotificationEventResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_events = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->events.clear(); + uint32_t _size1130; + ::apache::thrift::protocol::TType _etype1133; + xfer += iprot->readListBegin(_etype1133, _size1130); + this->events.resize(_size1130); + uint32_t _i1134; + for (_i1134 = 0; _i1134 < _size1130; ++_i1134) + { + xfer += this->events[_i1134].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_events = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_events) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t NotificationEventResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("NotificationEventResponse"); + + xfer += oprot->writeFieldBegin("events", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->events.size())); + std::vector ::const_iterator _iter1135; + for (_iter1135 = this->events.begin(); _iter1135 != this->events.end(); ++_iter1135) + { + xfer += (*_iter1135).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(NotificationEventResponse &a, NotificationEventResponse &b) noexcept { + using ::std::swap; + swap(a.events, b.events); +} + +bool NotificationEventResponse::operator==(const NotificationEventResponse & rhs) const +{ + if (!(events == rhs.events)) + return false; + return true; +} + +NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other1136) { + events = other1136.events; +} +NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other1137) { + events = other1137.events; + return *this; +} +void NotificationEventResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "NotificationEventResponse("; + out << "events=" << to_string(events); + out << ")"; +} + + +CurrentNotificationEventId::~CurrentNotificationEventId() noexcept { +} + +CurrentNotificationEventId::CurrentNotificationEventId() noexcept + : eventId(0) { +} + +void CurrentNotificationEventId::__set_eventId(const int64_t val) { + this->eventId = val; +} +std::ostream& operator<<(std::ostream& out, const CurrentNotificationEventId& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t CurrentNotificationEventId::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_eventId = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->eventId); + isset_eventId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_eventId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t CurrentNotificationEventId::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CurrentNotificationEventId"); + + xfer += oprot->writeFieldBegin("eventId", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->eventId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) noexcept { + using ::std::swap; + swap(a.eventId, b.eventId); +} + +bool CurrentNotificationEventId::operator==(const CurrentNotificationEventId & rhs) const +{ + if (!(eventId == rhs.eventId)) + return false; + return true; +} + +CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other1138) noexcept { + eventId = other1138.eventId; +} +CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other1139) noexcept { + eventId = other1139.eventId; + return *this; +} +void CurrentNotificationEventId::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CurrentNotificationEventId("; + out << "eventId=" << to_string(eventId); + out << ")"; +} + + +NotificationEventsCountRequest::~NotificationEventsCountRequest() noexcept { +} + +NotificationEventsCountRequest::NotificationEventsCountRequest() noexcept + : fromEventId(0), + dbName(), + catName(), + toEventId(0), + limit(0) { +} + +void NotificationEventsCountRequest::__set_fromEventId(const int64_t val) { + this->fromEventId = val; +} + +void NotificationEventsCountRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void NotificationEventsCountRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void NotificationEventsCountRequest::__set_toEventId(const int64_t val) { + this->toEventId = val; +__isset.toEventId = true; +} + +void NotificationEventsCountRequest::__set_limit(const int64_t val) { + this->limit = val; +__isset.limit = true; +} + +void NotificationEventsCountRequest::__set_tableNames(const std::vector & val) { + this->tableNames = val; +__isset.tableNames = true; +} +std::ostream& operator<<(std::ostream& out, const NotificationEventsCountRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t NotificationEventsCountRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_fromEventId = false; + bool isset_dbName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->fromEventId); + isset_fromEventId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->toEventId); + this->__isset.toEventId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->limit); + this->__isset.limit = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->tableNames.clear(); + uint32_t _size1140; + ::apache::thrift::protocol::TType _etype1143; + xfer += iprot->readListBegin(_etype1143, _size1140); + this->tableNames.resize(_size1140); + uint32_t _i1144; + for (_i1144 = 0; _i1144 < _size1140; ++_i1144) + { + xfer += iprot->readString(this->tableNames[_i1144]); + } + xfer += iprot->readListEnd(); + } + this->__isset.tableNames = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_fromEventId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t NotificationEventsCountRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("NotificationEventsCountRequest"); + + xfer += oprot->writeFieldBegin("fromEventId", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->fromEventId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.toEventId) { + xfer += oprot->writeFieldBegin("toEventId", ::apache::thrift::protocol::T_I64, 4); + xfer += oprot->writeI64(this->toEventId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.limit) { + xfer += oprot->writeFieldBegin("limit", ::apache::thrift::protocol::T_I64, 5); + xfer += oprot->writeI64(this->limit); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.tableNames) { + xfer += oprot->writeFieldBegin("tableNames", ::apache::thrift::protocol::T_LIST, 6); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tableNames.size())); + std::vector ::const_iterator _iter1145; + for (_iter1145 = this->tableNames.begin(); _iter1145 != this->tableNames.end(); ++_iter1145) + { + xfer += oprot->writeString((*_iter1145)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(NotificationEventsCountRequest &a, NotificationEventsCountRequest &b) noexcept { + using ::std::swap; + swap(a.fromEventId, b.fromEventId); + swap(a.dbName, b.dbName); + swap(a.catName, b.catName); + swap(a.toEventId, b.toEventId); + swap(a.limit, b.limit); + swap(a.tableNames, b.tableNames); + swap(a.__isset, b.__isset); +} + +bool NotificationEventsCountRequest::operator==(const NotificationEventsCountRequest & rhs) const +{ + if (!(fromEventId == rhs.fromEventId)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (__isset.toEventId != rhs.__isset.toEventId) + return false; + else if (__isset.toEventId && !(toEventId == rhs.toEventId)) + return false; + if (__isset.limit != rhs.__isset.limit) + return false; + else if (__isset.limit && !(limit == rhs.limit)) + return false; + if (__isset.tableNames != rhs.__isset.tableNames) + return false; + else if (__isset.tableNames && !(tableNames == rhs.tableNames)) + return false; + return true; +} + +NotificationEventsCountRequest::NotificationEventsCountRequest(const NotificationEventsCountRequest& other1146) { + fromEventId = other1146.fromEventId; + dbName = other1146.dbName; + catName = other1146.catName; + toEventId = other1146.toEventId; + limit = other1146.limit; + tableNames = other1146.tableNames; + __isset = other1146.__isset; +} +NotificationEventsCountRequest& NotificationEventsCountRequest::operator=(const NotificationEventsCountRequest& other1147) { + fromEventId = other1147.fromEventId; + dbName = other1147.dbName; + catName = other1147.catName; + toEventId = other1147.toEventId; + limit = other1147.limit; + tableNames = other1147.tableNames; + __isset = other1147.__isset; + return *this; +} +void NotificationEventsCountRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "NotificationEventsCountRequest("; + out << "fromEventId=" << to_string(fromEventId); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "toEventId="; (__isset.toEventId ? (out << to_string(toEventId)) : (out << "")); + out << ", " << "limit="; (__isset.limit ? (out << to_string(limit)) : (out << "")); + out << ", " << "tableNames="; (__isset.tableNames ? (out << to_string(tableNames)) : (out << "")); + out << ")"; +} + + +NotificationEventsCountResponse::~NotificationEventsCountResponse() noexcept { +} + +NotificationEventsCountResponse::NotificationEventsCountResponse() noexcept + : eventsCount(0) { +} + +void NotificationEventsCountResponse::__set_eventsCount(const int64_t val) { + this->eventsCount = val; +} +std::ostream& operator<<(std::ostream& out, const NotificationEventsCountResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t NotificationEventsCountResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_eventsCount = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->eventsCount); + isset_eventsCount = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_eventsCount) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t NotificationEventsCountResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("NotificationEventsCountResponse"); + + xfer += oprot->writeFieldBegin("eventsCount", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->eventsCount); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(NotificationEventsCountResponse &a, NotificationEventsCountResponse &b) noexcept { + using ::std::swap; + swap(a.eventsCount, b.eventsCount); +} + +bool NotificationEventsCountResponse::operator==(const NotificationEventsCountResponse & rhs) const +{ + if (!(eventsCount == rhs.eventsCount)) + return false; + return true; +} + +NotificationEventsCountResponse::NotificationEventsCountResponse(const NotificationEventsCountResponse& other1148) noexcept { + eventsCount = other1148.eventsCount; +} +NotificationEventsCountResponse& NotificationEventsCountResponse::operator=(const NotificationEventsCountResponse& other1149) noexcept { + eventsCount = other1149.eventsCount; + return *this; +} +void NotificationEventsCountResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "NotificationEventsCountResponse("; + out << "eventsCount=" << to_string(eventsCount); + out << ")"; +} + + +InsertEventRequestData::~InsertEventRequestData() noexcept { +} + +InsertEventRequestData::InsertEventRequestData() noexcept + : replace(0) { +} + +void InsertEventRequestData::__set_replace(const bool val) { + this->replace = val; +__isset.replace = true; +} + +void InsertEventRequestData::__set_filesAdded(const std::vector & val) { + this->filesAdded = val; +} + +void InsertEventRequestData::__set_filesAddedChecksum(const std::vector & val) { + this->filesAddedChecksum = val; +__isset.filesAddedChecksum = true; +} + +void InsertEventRequestData::__set_subDirectoryList(const std::vector & val) { + this->subDirectoryList = val; +__isset.subDirectoryList = true; +} + +void InsertEventRequestData::__set_partitionVal(const std::vector & val) { + this->partitionVal = val; +__isset.partitionVal = true; +} +std::ostream& operator<<(std::ostream& out, const InsertEventRequestData& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_filesAdded = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->replace); + this->__isset.replace = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->filesAdded.clear(); + uint32_t _size1150; + ::apache::thrift::protocol::TType _etype1153; + xfer += iprot->readListBegin(_etype1153, _size1150); + this->filesAdded.resize(_size1150); + uint32_t _i1154; + for (_i1154 = 0; _i1154 < _size1150; ++_i1154) + { + xfer += iprot->readString(this->filesAdded[_i1154]); + } + xfer += iprot->readListEnd(); + } + isset_filesAdded = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->filesAddedChecksum.clear(); + uint32_t _size1155; + ::apache::thrift::protocol::TType _etype1158; + xfer += iprot->readListBegin(_etype1158, _size1155); + this->filesAddedChecksum.resize(_size1155); + uint32_t _i1159; + for (_i1159 = 0; _i1159 < _size1155; ++_i1159) + { + xfer += iprot->readString(this->filesAddedChecksum[_i1159]); + } + xfer += iprot->readListEnd(); + } + this->__isset.filesAddedChecksum = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->subDirectoryList.clear(); + uint32_t _size1160; + ::apache::thrift::protocol::TType _etype1163; + xfer += iprot->readListBegin(_etype1163, _size1160); + this->subDirectoryList.resize(_size1160); + uint32_t _i1164; + for (_i1164 = 0; _i1164 < _size1160; ++_i1164) + { + xfer += iprot->readString(this->subDirectoryList[_i1164]); + } + xfer += iprot->readListEnd(); + } + this->__isset.subDirectoryList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitionVal.clear(); + uint32_t _size1165; + ::apache::thrift::protocol::TType _etype1168; + xfer += iprot->readListBegin(_etype1168, _size1165); + this->partitionVal.resize(_size1165); + uint32_t _i1169; + for (_i1169 = 0; _i1169 < _size1165; ++_i1169) + { + xfer += iprot->readString(this->partitionVal[_i1169]); + } + xfer += iprot->readListEnd(); + } + this->__isset.partitionVal = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_filesAdded) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("InsertEventRequestData"); + + if (this->__isset.replace) { + xfer += oprot->writeFieldBegin("replace", ::apache::thrift::protocol::T_BOOL, 1); + xfer += oprot->writeBool(this->replace); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("filesAdded", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->filesAdded.size())); + std::vector ::const_iterator _iter1170; + for (_iter1170 = this->filesAdded.begin(); _iter1170 != this->filesAdded.end(); ++_iter1170) + { + xfer += oprot->writeString((*_iter1170)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.filesAddedChecksum) { + xfer += oprot->writeFieldBegin("filesAddedChecksum", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->filesAddedChecksum.size())); + std::vector ::const_iterator _iter1171; + for (_iter1171 = this->filesAddedChecksum.begin(); _iter1171 != this->filesAddedChecksum.end(); ++_iter1171) + { + xfer += oprot->writeString((*_iter1171)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.subDirectoryList) { + xfer += oprot->writeFieldBegin("subDirectoryList", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->subDirectoryList.size())); + std::vector ::const_iterator _iter1172; + for (_iter1172 = this->subDirectoryList.begin(); _iter1172 != this->subDirectoryList.end(); ++_iter1172) + { + xfer += oprot->writeString((*_iter1172)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.partitionVal) { + xfer += oprot->writeFieldBegin("partitionVal", ::apache::thrift::protocol::T_LIST, 5); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionVal.size())); + std::vector ::const_iterator _iter1173; + for (_iter1173 = this->partitionVal.begin(); _iter1173 != this->partitionVal.end(); ++_iter1173) + { + xfer += oprot->writeString((*_iter1173)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(InsertEventRequestData &a, InsertEventRequestData &b) noexcept { + using ::std::swap; + swap(a.replace, b.replace); + swap(a.filesAdded, b.filesAdded); + swap(a.filesAddedChecksum, b.filesAddedChecksum); + swap(a.subDirectoryList, b.subDirectoryList); + swap(a.partitionVal, b.partitionVal); + swap(a.__isset, b.__isset); +} + +bool InsertEventRequestData::operator==(const InsertEventRequestData & rhs) const +{ + if (__isset.replace != rhs.__isset.replace) + return false; + else if (__isset.replace && !(replace == rhs.replace)) + return false; + if (!(filesAdded == rhs.filesAdded)) + return false; + if (__isset.filesAddedChecksum != rhs.__isset.filesAddedChecksum) + return false; + else if (__isset.filesAddedChecksum && !(filesAddedChecksum == rhs.filesAddedChecksum)) + return false; + if (__isset.subDirectoryList != rhs.__isset.subDirectoryList) + return false; + else if (__isset.subDirectoryList && !(subDirectoryList == rhs.subDirectoryList)) + return false; + if (__isset.partitionVal != rhs.__isset.partitionVal) + return false; + else if (__isset.partitionVal && !(partitionVal == rhs.partitionVal)) + return false; + return true; +} + +InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other1174) { + replace = other1174.replace; + filesAdded = other1174.filesAdded; + filesAddedChecksum = other1174.filesAddedChecksum; + subDirectoryList = other1174.subDirectoryList; + partitionVal = other1174.partitionVal; + __isset = other1174.__isset; +} +InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other1175) { + replace = other1175.replace; + filesAdded = other1175.filesAdded; + filesAddedChecksum = other1175.filesAddedChecksum; + subDirectoryList = other1175.subDirectoryList; + partitionVal = other1175.partitionVal; + __isset = other1175.__isset; + return *this; +} +void InsertEventRequestData::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "InsertEventRequestData("; + out << "replace="; (__isset.replace ? (out << to_string(replace)) : (out << "")); + out << ", " << "filesAdded=" << to_string(filesAdded); + out << ", " << "filesAddedChecksum="; (__isset.filesAddedChecksum ? (out << to_string(filesAddedChecksum)) : (out << "")); + out << ", " << "subDirectoryList="; (__isset.subDirectoryList ? (out << to_string(subDirectoryList)) : (out << "")); + out << ", " << "partitionVal="; (__isset.partitionVal ? (out << to_string(partitionVal)) : (out << "")); + out << ")"; +} + + +FireEventRequestData::~FireEventRequestData() noexcept { +} + +FireEventRequestData::FireEventRequestData() noexcept + : refreshEvent(0) { +} + +void FireEventRequestData::__set_insertData(const InsertEventRequestData& val) { + this->insertData = val; +__isset.insertData = true; +} + +void FireEventRequestData::__set_insertDatas(const std::vector & val) { + this->insertDatas = val; +__isset.insertDatas = true; +} + +void FireEventRequestData::__set_refreshEvent(const bool val) { + this->refreshEvent = val; +__isset.refreshEvent = true; +} +std::ostream& operator<<(std::ostream& out, const FireEventRequestData& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t FireEventRequestData::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->insertData.read(iprot); + this->__isset.insertData = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->insertDatas.clear(); + uint32_t _size1176; + ::apache::thrift::protocol::TType _etype1179; + xfer += iprot->readListBegin(_etype1179, _size1176); + this->insertDatas.resize(_size1176); + uint32_t _i1180; + for (_i1180 = 0; _i1180 < _size1176; ++_i1180) + { + xfer += this->insertDatas[_i1180].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.insertDatas = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->refreshEvent); + this->__isset.refreshEvent = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FireEventRequestData::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FireEventRequestData"); + + if (this->__isset.insertData) { + xfer += oprot->writeFieldBegin("insertData", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->insertData.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.insertDatas) { + xfer += oprot->writeFieldBegin("insertDatas", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->insertDatas.size())); + std::vector ::const_iterator _iter1181; + for (_iter1181 = this->insertDatas.begin(); _iter1181 != this->insertDatas.end(); ++_iter1181) + { + xfer += (*_iter1181).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.refreshEvent) { + xfer += oprot->writeFieldBegin("refreshEvent", ::apache::thrift::protocol::T_BOOL, 3); + xfer += oprot->writeBool(this->refreshEvent); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(FireEventRequestData &a, FireEventRequestData &b) noexcept { + using ::std::swap; + swap(a.insertData, b.insertData); + swap(a.insertDatas, b.insertDatas); + swap(a.refreshEvent, b.refreshEvent); + swap(a.__isset, b.__isset); +} + +bool FireEventRequestData::operator==(const FireEventRequestData & rhs) const +{ + if (__isset.insertData != rhs.__isset.insertData) + return false; + else if (__isset.insertData && !(insertData == rhs.insertData)) + return false; + if (__isset.insertDatas != rhs.__isset.insertDatas) + return false; + else if (__isset.insertDatas && !(insertDatas == rhs.insertDatas)) + return false; + if (__isset.refreshEvent != rhs.__isset.refreshEvent) + return false; + else if (__isset.refreshEvent && !(refreshEvent == rhs.refreshEvent)) + return false; + return true; +} + +FireEventRequestData::FireEventRequestData(const FireEventRequestData& other1182) { + insertData = other1182.insertData; + insertDatas = other1182.insertDatas; + refreshEvent = other1182.refreshEvent; + __isset = other1182.__isset; +} +FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other1183) { + insertData = other1183.insertData; + insertDatas = other1183.insertDatas; + refreshEvent = other1183.refreshEvent; + __isset = other1183.__isset; + return *this; +} +void FireEventRequestData::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "FireEventRequestData("; + out << "insertData="; (__isset.insertData ? (out << to_string(insertData)) : (out << "")); + out << ", " << "insertDatas="; (__isset.insertDatas ? (out << to_string(insertDatas)) : (out << "")); + out << ", " << "refreshEvent="; (__isset.refreshEvent ? (out << to_string(refreshEvent)) : (out << "")); + out << ")"; +} + + +FireEventRequest::~FireEventRequest() noexcept { +} + +FireEventRequest::FireEventRequest() noexcept + : successful(0), + dbName(), + tableName(), + catName() { +} + +void FireEventRequest::__set_successful(const bool val) { + this->successful = val; +} + +void FireEventRequest::__set_data(const FireEventRequestData& val) { + this->data = val; +} + +void FireEventRequest::__set_dbName(const std::string& val) { + this->dbName = val; +__isset.dbName = true; +} + +void FireEventRequest::__set_tableName(const std::string& val) { + this->tableName = val; +__isset.tableName = true; +} + +void FireEventRequest::__set_partitionVals(const std::vector & val) { + this->partitionVals = val; +__isset.partitionVals = true; +} + +void FireEventRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void FireEventRequest::__set_tblParams(const std::map & val) { + this->tblParams = val; +__isset.tblParams = true; +} +std::ostream& operator<<(std::ostream& out, const FireEventRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t FireEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_successful = false; + bool isset_data = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->successful); + isset_successful = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->data.read(iprot); + isset_data = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + this->__isset.tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitionVals.clear(); + uint32_t _size1184; + ::apache::thrift::protocol::TType _etype1187; + xfer += iprot->readListBegin(_etype1187, _size1184); + this->partitionVals.resize(_size1184); + uint32_t _i1188; + for (_i1188 = 0; _i1188 < _size1184; ++_i1188) + { + xfer += iprot->readString(this->partitionVals[_i1188]); + } + xfer += iprot->readListEnd(); + } + this->__isset.partitionVals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->tblParams.clear(); + uint32_t _size1189; + ::apache::thrift::protocol::TType _ktype1190; + ::apache::thrift::protocol::TType _vtype1191; + xfer += iprot->readMapBegin(_ktype1190, _vtype1191, _size1189); + uint32_t _i1193; + for (_i1193 = 0; _i1193 < _size1189; ++_i1193) + { + std::string _key1194; + xfer += iprot->readString(_key1194); + std::string& _val1195 = this->tblParams[_key1194]; + xfer += iprot->readString(_val1195); + } + xfer += iprot->readMapEnd(); + } + this->__isset.tblParams = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_successful) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_data) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t FireEventRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FireEventRequest"); + + xfer += oprot->writeFieldBegin("successful", ::apache::thrift::protocol::T_BOOL, 1); + xfer += oprot->writeBool(this->successful); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("data", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->data.write(oprot); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.dbName) { + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.tableName) { + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.partitionVals) { + xfer += oprot->writeFieldBegin("partitionVals", ::apache::thrift::protocol::T_LIST, 5); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionVals.size())); + std::vector ::const_iterator _iter1196; + for (_iter1196 = this->partitionVals.begin(); _iter1196 != this->partitionVals.end(); ++_iter1196) + { + xfer += oprot->writeString((*_iter1196)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.tblParams) { + xfer += oprot->writeFieldBegin("tblParams", ::apache::thrift::protocol::T_MAP, 7); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->tblParams.size())); + std::map ::const_iterator _iter1197; + for (_iter1197 = this->tblParams.begin(); _iter1197 != this->tblParams.end(); ++_iter1197) + { + xfer += oprot->writeString(_iter1197->first); + xfer += oprot->writeString(_iter1197->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(FireEventRequest &a, FireEventRequest &b) noexcept { + using ::std::swap; + swap(a.successful, b.successful); + swap(a.data, b.data); + swap(a.dbName, b.dbName); + swap(a.tableName, b.tableName); + swap(a.partitionVals, b.partitionVals); + swap(a.catName, b.catName); + swap(a.tblParams, b.tblParams); + swap(a.__isset, b.__isset); +} + +bool FireEventRequest::operator==(const FireEventRequest & rhs) const +{ + if (!(successful == rhs.successful)) + return false; + if (!(data == rhs.data)) + return false; + if (__isset.dbName != rhs.__isset.dbName) + return false; + else if (__isset.dbName && !(dbName == rhs.dbName)) + return false; + if (__isset.tableName != rhs.__isset.tableName) + return false; + else if (__isset.tableName && !(tableName == rhs.tableName)) + return false; + if (__isset.partitionVals != rhs.__isset.partitionVals) + return false; + else if (__isset.partitionVals && !(partitionVals == rhs.partitionVals)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (__isset.tblParams != rhs.__isset.tblParams) + return false; + else if (__isset.tblParams && !(tblParams == rhs.tblParams)) + return false; + return true; +} + +FireEventRequest::FireEventRequest(const FireEventRequest& other1198) { + successful = other1198.successful; + data = other1198.data; + dbName = other1198.dbName; + tableName = other1198.tableName; + partitionVals = other1198.partitionVals; + catName = other1198.catName; + tblParams = other1198.tblParams; + __isset = other1198.__isset; +} +FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other1199) { + successful = other1199.successful; + data = other1199.data; + dbName = other1199.dbName; + tableName = other1199.tableName; + partitionVals = other1199.partitionVals; + catName = other1199.catName; + tblParams = other1199.tblParams; + __isset = other1199.__isset; + return *this; +} +void FireEventRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "FireEventRequest("; + out << "successful=" << to_string(successful); + out << ", " << "data=" << to_string(data); + out << ", " << "dbName="; (__isset.dbName ? (out << to_string(dbName)) : (out << "")); + out << ", " << "tableName="; (__isset.tableName ? (out << to_string(tableName)) : (out << "")); + out << ", " << "partitionVals="; (__isset.partitionVals ? (out << to_string(partitionVals)) : (out << "")); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "tblParams="; (__isset.tblParams ? (out << to_string(tblParams)) : (out << "")); + out << ")"; +} + + +FireEventResponse::~FireEventResponse() noexcept { +} + +FireEventResponse::FireEventResponse() noexcept { +} + +void FireEventResponse::__set_eventIds(const std::vector & val) { + this->eventIds = val; +} +std::ostream& operator<<(std::ostream& out, const FireEventResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t FireEventResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->eventIds.clear(); + uint32_t _size1200; + ::apache::thrift::protocol::TType _etype1203; + xfer += iprot->readListBegin(_etype1203, _size1200); + this->eventIds.resize(_size1200); + uint32_t _i1204; + for (_i1204 = 0; _i1204 < _size1200; ++_i1204) + { + xfer += iprot->readI64(this->eventIds[_i1204]); + } + xfer += iprot->readListEnd(); + } + this->__isset.eventIds = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FireEventResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FireEventResponse"); + + xfer += oprot->writeFieldBegin("eventIds", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->eventIds.size())); + std::vector ::const_iterator _iter1205; + for (_iter1205 = this->eventIds.begin(); _iter1205 != this->eventIds.end(); ++_iter1205) + { + xfer += oprot->writeI64((*_iter1205)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(FireEventResponse &a, FireEventResponse &b) noexcept { + using ::std::swap; + swap(a.eventIds, b.eventIds); + swap(a.__isset, b.__isset); +} + +bool FireEventResponse::operator==(const FireEventResponse & rhs) const +{ + if (!(eventIds == rhs.eventIds)) + return false; + return true; +} + +FireEventResponse::FireEventResponse(const FireEventResponse& other1206) { + eventIds = other1206.eventIds; + __isset = other1206.__isset; +} +FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other1207) { + eventIds = other1207.eventIds; + __isset = other1207.__isset; + return *this; +} +void FireEventResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "FireEventResponse("; + out << "eventIds=" << to_string(eventIds); + out << ")"; +} + + +WriteNotificationLogRequest::~WriteNotificationLogRequest() noexcept { +} + +WriteNotificationLogRequest::WriteNotificationLogRequest() noexcept + : txnId(0), + writeId(0), + db(), + table() { +} + +void WriteNotificationLogRequest::__set_txnId(const int64_t val) { + this->txnId = val; +} + +void WriteNotificationLogRequest::__set_writeId(const int64_t val) { + this->writeId = val; +} + +void WriteNotificationLogRequest::__set_db(const std::string& val) { + this->db = val; +} + +void WriteNotificationLogRequest::__set_table(const std::string& val) { + this->table = val; +} + +void WriteNotificationLogRequest::__set_fileInfo(const InsertEventRequestData& val) { + this->fileInfo = val; +} + +void WriteNotificationLogRequest::__set_partitionVals(const std::vector & val) { + this->partitionVals = val; +__isset.partitionVals = true; +} +std::ostream& operator<<(std::ostream& out, const WriteNotificationLogRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WriteNotificationLogRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_txnId = false; + bool isset_writeId = false; + bool isset_db = false; + bool isset_table = false; + bool isset_fileInfo = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnId); + isset_txnId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->writeId); + isset_writeId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db); + isset_db = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->table); + isset_table = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->fileInfo.read(iprot); + isset_fileInfo = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitionVals.clear(); + uint32_t _size1208; + ::apache::thrift::protocol::TType _etype1211; + xfer += iprot->readListBegin(_etype1211, _size1208); + this->partitionVals.resize(_size1208); + uint32_t _i1212; + for (_i1212 = 0; _i1212 < _size1208; ++_i1212) + { + xfer += iprot->readString(this->partitionVals[_i1212]); + } + xfer += iprot->readListEnd(); + } + this->__isset.partitionVals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_txnId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_writeId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_db) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_table) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_fileInfo) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t WriteNotificationLogRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WriteNotificationLogRequest"); + + xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->txnId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("writeId", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->writeId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("db", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->db); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->table); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("fileInfo", ::apache::thrift::protocol::T_STRUCT, 5); + xfer += this->fileInfo.write(oprot); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.partitionVals) { + xfer += oprot->writeFieldBegin("partitionVals", ::apache::thrift::protocol::T_LIST, 6); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionVals.size())); + std::vector ::const_iterator _iter1213; + for (_iter1213 = this->partitionVals.begin(); _iter1213 != this->partitionVals.end(); ++_iter1213) + { + xfer += oprot->writeString((*_iter1213)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WriteNotificationLogRequest &a, WriteNotificationLogRequest &b) noexcept { + using ::std::swap; + swap(a.txnId, b.txnId); + swap(a.writeId, b.writeId); + swap(a.db, b.db); + swap(a.table, b.table); + swap(a.fileInfo, b.fileInfo); + swap(a.partitionVals, b.partitionVals); + swap(a.__isset, b.__isset); +} + +bool WriteNotificationLogRequest::operator==(const WriteNotificationLogRequest & rhs) const +{ + if (!(txnId == rhs.txnId)) + return false; + if (!(writeId == rhs.writeId)) + return false; + if (!(db == rhs.db)) + return false; + if (!(table == rhs.table)) + return false; + if (!(fileInfo == rhs.fileInfo)) + return false; + if (__isset.partitionVals != rhs.__isset.partitionVals) + return false; + else if (__isset.partitionVals && !(partitionVals == rhs.partitionVals)) + return false; + return true; +} + +WriteNotificationLogRequest::WriteNotificationLogRequest(const WriteNotificationLogRequest& other1214) { + txnId = other1214.txnId; + writeId = other1214.writeId; + db = other1214.db; + table = other1214.table; + fileInfo = other1214.fileInfo; + partitionVals = other1214.partitionVals; + __isset = other1214.__isset; +} +WriteNotificationLogRequest& WriteNotificationLogRequest::operator=(const WriteNotificationLogRequest& other1215) { + txnId = other1215.txnId; + writeId = other1215.writeId; + db = other1215.db; + table = other1215.table; + fileInfo = other1215.fileInfo; + partitionVals = other1215.partitionVals; + __isset = other1215.__isset; + return *this; +} +void WriteNotificationLogRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WriteNotificationLogRequest("; + out << "txnId=" << to_string(txnId); + out << ", " << "writeId=" << to_string(writeId); + out << ", " << "db=" << to_string(db); + out << ", " << "table=" << to_string(table); + out << ", " << "fileInfo=" << to_string(fileInfo); + out << ", " << "partitionVals="; (__isset.partitionVals ? (out << to_string(partitionVals)) : (out << "")); + out << ")"; +} + + +WriteNotificationLogResponse::~WriteNotificationLogResponse() noexcept { +} + +WriteNotificationLogResponse::WriteNotificationLogResponse() noexcept { +} +std::ostream& operator<<(std::ostream& out, const WriteNotificationLogResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WriteNotificationLogResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WriteNotificationLogResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WriteNotificationLogResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WriteNotificationLogResponse &a, WriteNotificationLogResponse &b) noexcept { + using ::std::swap; + (void) a; + (void) b; +} + +bool WriteNotificationLogResponse::operator==(const WriteNotificationLogResponse & /* rhs */) const +{ + return true; +} + +WriteNotificationLogResponse::WriteNotificationLogResponse(const WriteNotificationLogResponse& other1216) noexcept { + (void) other1216; +} +WriteNotificationLogResponse& WriteNotificationLogResponse::operator=(const WriteNotificationLogResponse& other1217) noexcept { + (void) other1217; + return *this; +} +void WriteNotificationLogResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WriteNotificationLogResponse("; + out << ")"; +} + + +WriteNotificationLogBatchRequest::~WriteNotificationLogBatchRequest() noexcept { +} + +WriteNotificationLogBatchRequest::WriteNotificationLogBatchRequest() noexcept + : catalog(), + db(), + table() { +} + +void WriteNotificationLogBatchRequest::__set_catalog(const std::string& val) { + this->catalog = val; +} + +void WriteNotificationLogBatchRequest::__set_db(const std::string& val) { + this->db = val; +} + +void WriteNotificationLogBatchRequest::__set_table(const std::string& val) { + this->table = val; +} + +void WriteNotificationLogBatchRequest::__set_requestList(const std::vector & val) { + this->requestList = val; +} +std::ostream& operator<<(std::ostream& out, const WriteNotificationLogBatchRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WriteNotificationLogBatchRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_catalog = false; + bool isset_db = false; + bool isset_table = false; + bool isset_requestList = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catalog); + isset_catalog = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db); + isset_db = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->table); + isset_table = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->requestList.clear(); + uint32_t _size1218; + ::apache::thrift::protocol::TType _etype1221; + xfer += iprot->readListBegin(_etype1221, _size1218); + this->requestList.resize(_size1218); + uint32_t _i1222; + for (_i1222 = 0; _i1222 < _size1218; ++_i1222) + { + xfer += this->requestList[_i1222].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_requestList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_catalog) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_db) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_table) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_requestList) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t WriteNotificationLogBatchRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WriteNotificationLogBatchRequest"); + + xfer += oprot->writeFieldBegin("catalog", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catalog); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("db", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->db); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->table); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("requestList", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->requestList.size())); + std::vector ::const_iterator _iter1223; + for (_iter1223 = this->requestList.begin(); _iter1223 != this->requestList.end(); ++_iter1223) + { + xfer += (*_iter1223).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WriteNotificationLogBatchRequest &a, WriteNotificationLogBatchRequest &b) noexcept { + using ::std::swap; + swap(a.catalog, b.catalog); + swap(a.db, b.db); + swap(a.table, b.table); + swap(a.requestList, b.requestList); +} + +bool WriteNotificationLogBatchRequest::operator==(const WriteNotificationLogBatchRequest & rhs) const +{ + if (!(catalog == rhs.catalog)) + return false; + if (!(db == rhs.db)) + return false; + if (!(table == rhs.table)) + return false; + if (!(requestList == rhs.requestList)) + return false; + return true; +} + +WriteNotificationLogBatchRequest::WriteNotificationLogBatchRequest(const WriteNotificationLogBatchRequest& other1224) { + catalog = other1224.catalog; + db = other1224.db; + table = other1224.table; + requestList = other1224.requestList; +} +WriteNotificationLogBatchRequest& WriteNotificationLogBatchRequest::operator=(const WriteNotificationLogBatchRequest& other1225) { + catalog = other1225.catalog; + db = other1225.db; + table = other1225.table; + requestList = other1225.requestList; + return *this; +} +void WriteNotificationLogBatchRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WriteNotificationLogBatchRequest("; + out << "catalog=" << to_string(catalog); + out << ", " << "db=" << to_string(db); + out << ", " << "table=" << to_string(table); + out << ", " << "requestList=" << to_string(requestList); + out << ")"; +} + + +WriteNotificationLogBatchResponse::~WriteNotificationLogBatchResponse() noexcept { +} + +WriteNotificationLogBatchResponse::WriteNotificationLogBatchResponse() noexcept { +} +std::ostream& operator<<(std::ostream& out, const WriteNotificationLogBatchResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WriteNotificationLogBatchResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WriteNotificationLogBatchResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WriteNotificationLogBatchResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WriteNotificationLogBatchResponse &a, WriteNotificationLogBatchResponse &b) noexcept { + using ::std::swap; + (void) a; + (void) b; +} + +bool WriteNotificationLogBatchResponse::operator==(const WriteNotificationLogBatchResponse & /* rhs */) const +{ + return true; +} + +WriteNotificationLogBatchResponse::WriteNotificationLogBatchResponse(const WriteNotificationLogBatchResponse& other1226) noexcept { + (void) other1226; +} +WriteNotificationLogBatchResponse& WriteNotificationLogBatchResponse::operator=(const WriteNotificationLogBatchResponse& other1227) noexcept { + (void) other1227; + return *this; +} +void WriteNotificationLogBatchResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WriteNotificationLogBatchResponse("; + out << ")"; +} + + +MetadataPpdResult::~MetadataPpdResult() noexcept { +} + +MetadataPpdResult::MetadataPpdResult() noexcept + : metadata(), + includeBitset() { +} + +void MetadataPpdResult::__set_metadata(const std::string& val) { + this->metadata = val; +__isset.metadata = true; +} + +void MetadataPpdResult::__set_includeBitset(const std::string& val) { + this->includeBitset = val; +__isset.includeBitset = true; +} +std::ostream& operator<<(std::ostream& out, const MetadataPpdResult& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t MetadataPpdResult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->metadata); + this->__isset.metadata = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->includeBitset); + this->__isset.includeBitset = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t MetadataPpdResult::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("MetadataPpdResult"); + + if (this->__isset.metadata) { + xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeBinary(this->metadata); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.includeBitset) { + xfer += oprot->writeFieldBegin("includeBitset", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeBinary(this->includeBitset); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(MetadataPpdResult &a, MetadataPpdResult &b) noexcept { + using ::std::swap; + swap(a.metadata, b.metadata); + swap(a.includeBitset, b.includeBitset); + swap(a.__isset, b.__isset); +} + +bool MetadataPpdResult::operator==(const MetadataPpdResult & rhs) const +{ + if (__isset.metadata != rhs.__isset.metadata) + return false; + else if (__isset.metadata && !(metadata == rhs.metadata)) + return false; + if (__isset.includeBitset != rhs.__isset.includeBitset) + return false; + else if (__isset.includeBitset && !(includeBitset == rhs.includeBitset)) + return false; + return true; +} + +MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other1228) { + metadata = other1228.metadata; + includeBitset = other1228.includeBitset; + __isset = other1228.__isset; +} +MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other1229) { + metadata = other1229.metadata; + includeBitset = other1229.includeBitset; + __isset = other1229.__isset; + return *this; +} +void MetadataPpdResult::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "MetadataPpdResult("; + out << "metadata="; (__isset.metadata ? (out << to_string(metadata)) : (out << "")); + out << ", " << "includeBitset="; (__isset.includeBitset ? (out << to_string(includeBitset)) : (out << "")); + out << ")"; +} + + +GetFileMetadataByExprResult::~GetFileMetadataByExprResult() noexcept { +} + +GetFileMetadataByExprResult::GetFileMetadataByExprResult() noexcept + : isSupported(0) { +} + +void GetFileMetadataByExprResult::__set_metadata(const std::map & val) { + this->metadata = val; +} + +void GetFileMetadataByExprResult::__set_isSupported(const bool val) { + this->isSupported = val; +} +std::ostream& operator<<(std::ostream& out, const GetFileMetadataByExprResult& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetFileMetadataByExprResult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_metadata = false; + bool isset_isSupported = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->metadata.clear(); + uint32_t _size1230; + ::apache::thrift::protocol::TType _ktype1231; + ::apache::thrift::protocol::TType _vtype1232; + xfer += iprot->readMapBegin(_ktype1231, _vtype1232, _size1230); + uint32_t _i1234; + for (_i1234 = 0; _i1234 < _size1230; ++_i1234) + { + int64_t _key1235; + xfer += iprot->readI64(_key1235); + MetadataPpdResult& _val1236 = this->metadata[_key1235]; + xfer += _val1236.read(iprot); + } + xfer += iprot->readMapEnd(); + } + isset_metadata = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isSupported); + isset_isSupported = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_metadata) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_isSupported) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetFileMetadataByExprResult::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetFileMetadataByExprResult"); + + xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_MAP, 1); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I64, ::apache::thrift::protocol::T_STRUCT, static_cast(this->metadata.size())); + std::map ::const_iterator _iter1237; + for (_iter1237 = this->metadata.begin(); _iter1237 != this->metadata.end(); ++_iter1237) + { + xfer += oprot->writeI64(_iter1237->first); + xfer += _iter1237->second.write(oprot); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("isSupported", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool(this->isSupported); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetFileMetadataByExprResult &a, GetFileMetadataByExprResult &b) noexcept { + using ::std::swap; + swap(a.metadata, b.metadata); + swap(a.isSupported, b.isSupported); +} + +bool GetFileMetadataByExprResult::operator==(const GetFileMetadataByExprResult & rhs) const +{ + if (!(metadata == rhs.metadata)) + return false; + if (!(isSupported == rhs.isSupported)) + return false; + return true; +} + +GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other1238) { + metadata = other1238.metadata; + isSupported = other1238.isSupported; +} +GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other1239) { + metadata = other1239.metadata; + isSupported = other1239.isSupported; + return *this; +} +void GetFileMetadataByExprResult::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetFileMetadataByExprResult("; + out << "metadata=" << to_string(metadata); + out << ", " << "isSupported=" << to_string(isSupported); + out << ")"; +} + + +GetFileMetadataByExprRequest::~GetFileMetadataByExprRequest() noexcept { +} + +GetFileMetadataByExprRequest::GetFileMetadataByExprRequest() noexcept + : expr(), + doGetFooters(0), + type(static_cast(0)) { +} + +void GetFileMetadataByExprRequest::__set_fileIds(const std::vector & val) { + this->fileIds = val; +} + +void GetFileMetadataByExprRequest::__set_expr(const std::string& val) { + this->expr = val; +} + +void GetFileMetadataByExprRequest::__set_doGetFooters(const bool val) { + this->doGetFooters = val; +__isset.doGetFooters = true; +} + +void GetFileMetadataByExprRequest::__set_type(const FileMetadataExprType::type val) { + this->type = val; +__isset.type = true; +} +std::ostream& operator<<(std::ostream& out, const GetFileMetadataByExprRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_fileIds = false; + bool isset_expr = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->fileIds.clear(); + uint32_t _size1240; + ::apache::thrift::protocol::TType _etype1243; + xfer += iprot->readListBegin(_etype1243, _size1240); + this->fileIds.resize(_size1240); + uint32_t _i1244; + for (_i1244 = 0; _i1244 < _size1240; ++_i1244) + { + xfer += iprot->readI64(this->fileIds[_i1244]); + } + xfer += iprot->readListEnd(); + } + isset_fileIds = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->expr); + isset_expr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->doGetFooters); + this->__isset.doGetFooters = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1245; + xfer += iprot->readI32(ecast1245); + this->type = static_cast(ecast1245); + this->__isset.type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_fileIds) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_expr) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetFileMetadataByExprRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetFileMetadataByExprRequest"); + + xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); + std::vector ::const_iterator _iter1246; + for (_iter1246 = this->fileIds.begin(); _iter1246 != this->fileIds.end(); ++_iter1246) + { + xfer += oprot->writeI64((*_iter1246)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("expr", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeBinary(this->expr); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.doGetFooters) { + xfer += oprot->writeFieldBegin("doGetFooters", ::apache::thrift::protocol::T_BOOL, 3); + xfer += oprot->writeBool(this->doGetFooters); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.type) { + xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32(static_cast(this->type)); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetFileMetadataByExprRequest &a, GetFileMetadataByExprRequest &b) noexcept { + using ::std::swap; + swap(a.fileIds, b.fileIds); + swap(a.expr, b.expr); + swap(a.doGetFooters, b.doGetFooters); + swap(a.type, b.type); + swap(a.__isset, b.__isset); +} + +bool GetFileMetadataByExprRequest::operator==(const GetFileMetadataByExprRequest & rhs) const +{ + if (!(fileIds == rhs.fileIds)) + return false; + if (!(expr == rhs.expr)) + return false; + if (__isset.doGetFooters != rhs.__isset.doGetFooters) + return false; + else if (__isset.doGetFooters && !(doGetFooters == rhs.doGetFooters)) + return false; + if (__isset.type != rhs.__isset.type) + return false; + else if (__isset.type && !(type == rhs.type)) + return false; + return true; +} + +GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other1247) { + fileIds = other1247.fileIds; + expr = other1247.expr; + doGetFooters = other1247.doGetFooters; + type = other1247.type; + __isset = other1247.__isset; +} +GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other1248) { + fileIds = other1248.fileIds; + expr = other1248.expr; + doGetFooters = other1248.doGetFooters; + type = other1248.type; + __isset = other1248.__isset; + return *this; +} +void GetFileMetadataByExprRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetFileMetadataByExprRequest("; + out << "fileIds=" << to_string(fileIds); + out << ", " << "expr=" << to_string(expr); + out << ", " << "doGetFooters="; (__isset.doGetFooters ? (out << to_string(doGetFooters)) : (out << "")); + out << ", " << "type="; (__isset.type ? (out << to_string(type)) : (out << "")); + out << ")"; +} + + +GetFileMetadataResult::~GetFileMetadataResult() noexcept { +} + +GetFileMetadataResult::GetFileMetadataResult() noexcept + : isSupported(0) { +} + +void GetFileMetadataResult::__set_metadata(const std::map & val) { + this->metadata = val; +} + +void GetFileMetadataResult::__set_isSupported(const bool val) { + this->isSupported = val; +} +std::ostream& operator<<(std::ostream& out, const GetFileMetadataResult& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetFileMetadataResult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_metadata = false; + bool isset_isSupported = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->metadata.clear(); + uint32_t _size1249; + ::apache::thrift::protocol::TType _ktype1250; + ::apache::thrift::protocol::TType _vtype1251; + xfer += iprot->readMapBegin(_ktype1250, _vtype1251, _size1249); + uint32_t _i1253; + for (_i1253 = 0; _i1253 < _size1249; ++_i1253) + { + int64_t _key1254; + xfer += iprot->readI64(_key1254); + std::string& _val1255 = this->metadata[_key1254]; + xfer += iprot->readBinary(_val1255); + } + xfer += iprot->readMapEnd(); + } + isset_metadata = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isSupported); + isset_isSupported = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_metadata) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_isSupported) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetFileMetadataResult::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetFileMetadataResult"); + + xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_MAP, 1); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I64, ::apache::thrift::protocol::T_STRING, static_cast(this->metadata.size())); + std::map ::const_iterator _iter1256; + for (_iter1256 = this->metadata.begin(); _iter1256 != this->metadata.end(); ++_iter1256) + { + xfer += oprot->writeI64(_iter1256->first); + xfer += oprot->writeBinary(_iter1256->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("isSupported", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool(this->isSupported); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetFileMetadataResult &a, GetFileMetadataResult &b) noexcept { + using ::std::swap; + swap(a.metadata, b.metadata); + swap(a.isSupported, b.isSupported); +} + +bool GetFileMetadataResult::operator==(const GetFileMetadataResult & rhs) const +{ + if (!(metadata == rhs.metadata)) + return false; + if (!(isSupported == rhs.isSupported)) + return false; + return true; +} + +GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other1257) { + metadata = other1257.metadata; + isSupported = other1257.isSupported; +} +GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other1258) { + metadata = other1258.metadata; + isSupported = other1258.isSupported; + return *this; +} +void GetFileMetadataResult::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetFileMetadataResult("; + out << "metadata=" << to_string(metadata); + out << ", " << "isSupported=" << to_string(isSupported); + out << ")"; +} + + +GetFileMetadataRequest::~GetFileMetadataRequest() noexcept { +} + +GetFileMetadataRequest::GetFileMetadataRequest() noexcept { +} + +void GetFileMetadataRequest::__set_fileIds(const std::vector & val) { + this->fileIds = val; +} +std::ostream& operator<<(std::ostream& out, const GetFileMetadataRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_fileIds = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->fileIds.clear(); + uint32_t _size1259; + ::apache::thrift::protocol::TType _etype1262; + xfer += iprot->readListBegin(_etype1262, _size1259); + this->fileIds.resize(_size1259); + uint32_t _i1263; + for (_i1263 = 0; _i1263 < _size1259; ++_i1263) + { + xfer += iprot->readI64(this->fileIds[_i1263]); + } + xfer += iprot->readListEnd(); + } + isset_fileIds = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_fileIds) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetFileMetadataRequest"); + + xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); + std::vector ::const_iterator _iter1264; + for (_iter1264 = this->fileIds.begin(); _iter1264 != this->fileIds.end(); ++_iter1264) + { + xfer += oprot->writeI64((*_iter1264)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetFileMetadataRequest &a, GetFileMetadataRequest &b) noexcept { + using ::std::swap; + swap(a.fileIds, b.fileIds); +} + +bool GetFileMetadataRequest::operator==(const GetFileMetadataRequest & rhs) const +{ + if (!(fileIds == rhs.fileIds)) + return false; + return true; +} + +GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other1265) { + fileIds = other1265.fileIds; +} +GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other1266) { + fileIds = other1266.fileIds; + return *this; +} +void GetFileMetadataRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetFileMetadataRequest("; + out << "fileIds=" << to_string(fileIds); + out << ")"; +} + + +PutFileMetadataResult::~PutFileMetadataResult() noexcept { +} + +PutFileMetadataResult::PutFileMetadataResult() noexcept { +} +std::ostream& operator<<(std::ostream& out, const PutFileMetadataResult& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PutFileMetadataResult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t PutFileMetadataResult::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PutFileMetadataResult"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PutFileMetadataResult &a, PutFileMetadataResult &b) noexcept { + using ::std::swap; + (void) a; + (void) b; +} + +bool PutFileMetadataResult::operator==(const PutFileMetadataResult & /* rhs */) const +{ + return true; +} + +PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other1267) noexcept { + (void) other1267; +} +PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other1268) noexcept { + (void) other1268; + return *this; +} +void PutFileMetadataResult::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PutFileMetadataResult("; + out << ")"; +} + + +PutFileMetadataRequest::~PutFileMetadataRequest() noexcept { +} + +PutFileMetadataRequest::PutFileMetadataRequest() noexcept + : type(static_cast(0)) { +} + +void PutFileMetadataRequest::__set_fileIds(const std::vector & val) { + this->fileIds = val; +} + +void PutFileMetadataRequest::__set_metadata(const std::vector & val) { + this->metadata = val; +} + +void PutFileMetadataRequest::__set_type(const FileMetadataExprType::type val) { + this->type = val; +__isset.type = true; +} +std::ostream& operator<<(std::ostream& out, const PutFileMetadataRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_fileIds = false; + bool isset_metadata = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->fileIds.clear(); + uint32_t _size1269; + ::apache::thrift::protocol::TType _etype1272; + xfer += iprot->readListBegin(_etype1272, _size1269); + this->fileIds.resize(_size1269); + uint32_t _i1273; + for (_i1273 = 0; _i1273 < _size1269; ++_i1273) + { + xfer += iprot->readI64(this->fileIds[_i1273]); + } + xfer += iprot->readListEnd(); + } + isset_fileIds = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->metadata.clear(); + uint32_t _size1274; + ::apache::thrift::protocol::TType _etype1277; + xfer += iprot->readListBegin(_etype1277, _size1274); + this->metadata.resize(_size1274); + uint32_t _i1278; + for (_i1278 = 0; _i1278 < _size1274; ++_i1278) + { + xfer += iprot->readBinary(this->metadata[_i1278]); + } + xfer += iprot->readListEnd(); + } + isset_metadata = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1279; + xfer += iprot->readI32(ecast1279); + this->type = static_cast(ecast1279); + this->__isset.type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_fileIds) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_metadata) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t PutFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PutFileMetadataRequest"); + + xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); + std::vector ::const_iterator _iter1280; + for (_iter1280 = this->fileIds.begin(); _iter1280 != this->fileIds.end(); ++_iter1280) + { + xfer += oprot->writeI64((*_iter1280)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->metadata.size())); + std::vector ::const_iterator _iter1281; + for (_iter1281 = this->metadata.begin(); _iter1281 != this->metadata.end(); ++_iter1281) + { + xfer += oprot->writeBinary((*_iter1281)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.type) { + xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32(static_cast(this->type)); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PutFileMetadataRequest &a, PutFileMetadataRequest &b) noexcept { + using ::std::swap; + swap(a.fileIds, b.fileIds); + swap(a.metadata, b.metadata); + swap(a.type, b.type); + swap(a.__isset, b.__isset); +} + +bool PutFileMetadataRequest::operator==(const PutFileMetadataRequest & rhs) const +{ + if (!(fileIds == rhs.fileIds)) + return false; + if (!(metadata == rhs.metadata)) + return false; + if (__isset.type != rhs.__isset.type) + return false; + else if (__isset.type && !(type == rhs.type)) + return false; + return true; +} + +PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other1282) { + fileIds = other1282.fileIds; + metadata = other1282.metadata; + type = other1282.type; + __isset = other1282.__isset; +} +PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other1283) { + fileIds = other1283.fileIds; + metadata = other1283.metadata; + type = other1283.type; + __isset = other1283.__isset; + return *this; +} +void PutFileMetadataRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PutFileMetadataRequest("; + out << "fileIds=" << to_string(fileIds); + out << ", " << "metadata=" << to_string(metadata); + out << ", " << "type="; (__isset.type ? (out << to_string(type)) : (out << "")); + out << ")"; +} + + +ClearFileMetadataResult::~ClearFileMetadataResult() noexcept { +} + +ClearFileMetadataResult::ClearFileMetadataResult() noexcept { +} +std::ostream& operator<<(std::ostream& out, const ClearFileMetadataResult& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ClearFileMetadataResult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ClearFileMetadataResult::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ClearFileMetadataResult"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ClearFileMetadataResult &a, ClearFileMetadataResult &b) noexcept { + using ::std::swap; + (void) a; + (void) b; +} + +bool ClearFileMetadataResult::operator==(const ClearFileMetadataResult & /* rhs */) const +{ + return true; +} + +ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other1284) noexcept { + (void) other1284; +} +ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other1285) noexcept { + (void) other1285; + return *this; +} +void ClearFileMetadataResult::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ClearFileMetadataResult("; + out << ")"; +} + + +ClearFileMetadataRequest::~ClearFileMetadataRequest() noexcept { +} + +ClearFileMetadataRequest::ClearFileMetadataRequest() noexcept { +} + +void ClearFileMetadataRequest::__set_fileIds(const std::vector & val) { + this->fileIds = val; +} +std::ostream& operator<<(std::ostream& out, const ClearFileMetadataRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ClearFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_fileIds = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->fileIds.clear(); + uint32_t _size1286; + ::apache::thrift::protocol::TType _etype1289; + xfer += iprot->readListBegin(_etype1289, _size1286); + this->fileIds.resize(_size1286); + uint32_t _i1290; + for (_i1290 = 0; _i1290 < _size1286; ++_i1290) + { + xfer += iprot->readI64(this->fileIds[_i1290]); + } + xfer += iprot->readListEnd(); + } + isset_fileIds = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_fileIds) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ClearFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ClearFileMetadataRequest"); + + xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); + std::vector ::const_iterator _iter1291; + for (_iter1291 = this->fileIds.begin(); _iter1291 != this->fileIds.end(); ++_iter1291) + { + xfer += oprot->writeI64((*_iter1291)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ClearFileMetadataRequest &a, ClearFileMetadataRequest &b) noexcept { + using ::std::swap; + swap(a.fileIds, b.fileIds); +} + +bool ClearFileMetadataRequest::operator==(const ClearFileMetadataRequest & rhs) const +{ + if (!(fileIds == rhs.fileIds)) + return false; + return true; +} + +ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other1292) { + fileIds = other1292.fileIds; +} +ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other1293) { + fileIds = other1293.fileIds; + return *this; +} +void ClearFileMetadataRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ClearFileMetadataRequest("; + out << "fileIds=" << to_string(fileIds); + out << ")"; +} + + +CacheFileMetadataResult::~CacheFileMetadataResult() noexcept { +} + +CacheFileMetadataResult::CacheFileMetadataResult() noexcept + : isSupported(0) { +} + +void CacheFileMetadataResult::__set_isSupported(const bool val) { + this->isSupported = val; +} +std::ostream& operator<<(std::ostream& out, const CacheFileMetadataResult& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t CacheFileMetadataResult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_isSupported = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isSupported); + isset_isSupported = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_isSupported) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t CacheFileMetadataResult::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CacheFileMetadataResult"); + + xfer += oprot->writeFieldBegin("isSupported", ::apache::thrift::protocol::T_BOOL, 1); + xfer += oprot->writeBool(this->isSupported); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CacheFileMetadataResult &a, CacheFileMetadataResult &b) noexcept { + using ::std::swap; + swap(a.isSupported, b.isSupported); +} + +bool CacheFileMetadataResult::operator==(const CacheFileMetadataResult & rhs) const +{ + if (!(isSupported == rhs.isSupported)) + return false; + return true; +} + +CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other1294) noexcept { + isSupported = other1294.isSupported; +} +CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other1295) noexcept { + isSupported = other1295.isSupported; + return *this; +} +void CacheFileMetadataResult::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CacheFileMetadataResult("; + out << "isSupported=" << to_string(isSupported); + out << ")"; +} + + +CacheFileMetadataRequest::~CacheFileMetadataRequest() noexcept { +} + +CacheFileMetadataRequest::CacheFileMetadataRequest() noexcept + : dbName(), + tblName(), + partName(), + isAllParts(0) { +} + +void CacheFileMetadataRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void CacheFileMetadataRequest::__set_tblName(const std::string& val) { + this->tblName = val; +} + +void CacheFileMetadataRequest::__set_partName(const std::string& val) { + this->partName = val; +__isset.partName = true; +} + +void CacheFileMetadataRequest::__set_isAllParts(const bool val) { + this->isAllParts = val; +__isset.isAllParts = true; +} +std::ostream& operator<<(std::ostream& out, const CacheFileMetadataRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t CacheFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tblName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tblName); + isset_tblName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->partName); + this->__isset.partName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isAllParts); + this->__isset.isAllParts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tblName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t CacheFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CacheFileMetadataRequest"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tblName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.partName) { + xfer += oprot->writeFieldBegin("partName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->partName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.isAllParts) { + xfer += oprot->writeFieldBegin("isAllParts", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool(this->isAllParts); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CacheFileMetadataRequest &a, CacheFileMetadataRequest &b) noexcept { + using ::std::swap; + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); + swap(a.partName, b.partName); + swap(a.isAllParts, b.isAllParts); + swap(a.__isset, b.__isset); +} + +bool CacheFileMetadataRequest::operator==(const CacheFileMetadataRequest & rhs) const +{ + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + if (__isset.partName != rhs.__isset.partName) + return false; + else if (__isset.partName && !(partName == rhs.partName)) + return false; + if (__isset.isAllParts != rhs.__isset.isAllParts) + return false; + else if (__isset.isAllParts && !(isAllParts == rhs.isAllParts)) + return false; + return true; +} + +CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other1296) { + dbName = other1296.dbName; + tblName = other1296.tblName; + partName = other1296.partName; + isAllParts = other1296.isAllParts; + __isset = other1296.__isset; +} +CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other1297) { + dbName = other1297.dbName; + tblName = other1297.tblName; + partName = other1297.partName; + isAllParts = other1297.isAllParts; + __isset = other1297.__isset; + return *this; +} +void CacheFileMetadataRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CacheFileMetadataRequest("; + out << "dbName=" << to_string(dbName); + out << ", " << "tblName=" << to_string(tblName); + out << ", " << "partName="; (__isset.partName ? (out << to_string(partName)) : (out << "")); + out << ", " << "isAllParts="; (__isset.isAllParts ? (out << to_string(isAllParts)) : (out << "")); + out << ")"; +} + + +GetAllFunctionsResponse::~GetAllFunctionsResponse() noexcept { +} + +GetAllFunctionsResponse::GetAllFunctionsResponse() noexcept { +} + +void GetAllFunctionsResponse::__set_functions(const std::vector & val) { + this->functions = val; +__isset.functions = true; +} +std::ostream& operator<<(std::ostream& out, const GetAllFunctionsResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetAllFunctionsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->functions.clear(); + uint32_t _size1298; + ::apache::thrift::protocol::TType _etype1301; + xfer += iprot->readListBegin(_etype1301, _size1298); + this->functions.resize(_size1298); + uint32_t _i1302; + for (_i1302 = 0; _i1302 < _size1298; ++_i1302) + { + xfer += this->functions[_i1302].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.functions = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t GetAllFunctionsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetAllFunctionsResponse"); + + if (this->__isset.functions) { + xfer += oprot->writeFieldBegin("functions", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->functions.size())); + std::vector ::const_iterator _iter1303; + for (_iter1303 = this->functions.begin(); _iter1303 != this->functions.end(); ++_iter1303) + { + xfer += (*_iter1303).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b) noexcept { + using ::std::swap; + swap(a.functions, b.functions); + swap(a.__isset, b.__isset); +} + +bool GetAllFunctionsResponse::operator==(const GetAllFunctionsResponse & rhs) const +{ + if (__isset.functions != rhs.__isset.functions) + return false; + else if (__isset.functions && !(functions == rhs.functions)) + return false; + return true; +} + +GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other1304) { + functions = other1304.functions; + __isset = other1304.__isset; +} +GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other1305) { + functions = other1305.functions; + __isset = other1305.__isset; + return *this; +} +void GetAllFunctionsResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetAllFunctionsResponse("; + out << "functions="; (__isset.functions ? (out << to_string(functions)) : (out << "")); + out << ")"; +} + + +ClientCapabilities::~ClientCapabilities() noexcept { +} + +ClientCapabilities::ClientCapabilities() noexcept { +} + +void ClientCapabilities::__set_values(const std::vector & val) { + this->values = val; +} +std::ostream& operator<<(std::ostream& out, const ClientCapabilities& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ClientCapabilities::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_values = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->values.clear(); + uint32_t _size1306; + ::apache::thrift::protocol::TType _etype1309; + xfer += iprot->readListBegin(_etype1309, _size1306); + this->values.resize(_size1306); + uint32_t _i1310; + for (_i1310 = 0; _i1310 < _size1306; ++_i1310) + { + int32_t ecast1311; + xfer += iprot->readI32(ecast1311); + this->values[_i1310] = static_cast(ecast1311); + } + xfer += iprot->readListEnd(); + } + isset_values = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_values) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ClientCapabilities::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ClientCapabilities"); + + xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I32, static_cast(this->values.size())); + std::vector ::const_iterator _iter1312; + for (_iter1312 = this->values.begin(); _iter1312 != this->values.end(); ++_iter1312) + { + xfer += oprot->writeI32(static_cast((*_iter1312))); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ClientCapabilities &a, ClientCapabilities &b) noexcept { + using ::std::swap; + swap(a.values, b.values); +} + +bool ClientCapabilities::operator==(const ClientCapabilities & rhs) const +{ + if (!(values == rhs.values)) + return false; + return true; +} + +ClientCapabilities::ClientCapabilities(const ClientCapabilities& other1313) { + values = other1313.values; +} +ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other1314) { + values = other1314.values; + return *this; +} +void ClientCapabilities::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ClientCapabilities("; + out << "values=" << to_string(values); + out << ")"; +} + + +GetProjectionsSpec::~GetProjectionsSpec() noexcept { +} + +GetProjectionsSpec::GetProjectionsSpec() noexcept + : includeParamKeyPattern(), + excludeParamKeyPattern() { +} + +void GetProjectionsSpec::__set_fieldList(const std::vector & val) { + this->fieldList = val; +} + +void GetProjectionsSpec::__set_includeParamKeyPattern(const std::string& val) { + this->includeParamKeyPattern = val; +} + +void GetProjectionsSpec::__set_excludeParamKeyPattern(const std::string& val) { + this->excludeParamKeyPattern = val; +} +std::ostream& operator<<(std::ostream& out, const GetProjectionsSpec& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetProjectionsSpec::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->fieldList.clear(); + uint32_t _size1315; + ::apache::thrift::protocol::TType _etype1318; + xfer += iprot->readListBegin(_etype1318, _size1315); + this->fieldList.resize(_size1315); + uint32_t _i1319; + for (_i1319 = 0; _i1319 < _size1315; ++_i1319) + { + xfer += iprot->readString(this->fieldList[_i1319]); + } + xfer += iprot->readListEnd(); + } + this->__isset.fieldList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->includeParamKeyPattern); + this->__isset.includeParamKeyPattern = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->excludeParamKeyPattern); + this->__isset.excludeParamKeyPattern = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t GetProjectionsSpec::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetProjectionsSpec"); + + xfer += oprot->writeFieldBegin("fieldList", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->fieldList.size())); + std::vector ::const_iterator _iter1320; + for (_iter1320 = this->fieldList.begin(); _iter1320 != this->fieldList.end(); ++_iter1320) + { + xfer += oprot->writeString((*_iter1320)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("includeParamKeyPattern", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->includeParamKeyPattern); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("excludeParamKeyPattern", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->excludeParamKeyPattern); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetProjectionsSpec &a, GetProjectionsSpec &b) noexcept { + using ::std::swap; + swap(a.fieldList, b.fieldList); + swap(a.includeParamKeyPattern, b.includeParamKeyPattern); + swap(a.excludeParamKeyPattern, b.excludeParamKeyPattern); + swap(a.__isset, b.__isset); +} + +bool GetProjectionsSpec::operator==(const GetProjectionsSpec & rhs) const +{ + if (!(fieldList == rhs.fieldList)) + return false; + if (!(includeParamKeyPattern == rhs.includeParamKeyPattern)) + return false; + if (!(excludeParamKeyPattern == rhs.excludeParamKeyPattern)) + return false; + return true; +} + +GetProjectionsSpec::GetProjectionsSpec(const GetProjectionsSpec& other1321) { + fieldList = other1321.fieldList; + includeParamKeyPattern = other1321.includeParamKeyPattern; + excludeParamKeyPattern = other1321.excludeParamKeyPattern; + __isset = other1321.__isset; +} +GetProjectionsSpec& GetProjectionsSpec::operator=(const GetProjectionsSpec& other1322) { + fieldList = other1322.fieldList; + includeParamKeyPattern = other1322.includeParamKeyPattern; + excludeParamKeyPattern = other1322.excludeParamKeyPattern; + __isset = other1322.__isset; + return *this; +} +void GetProjectionsSpec::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetProjectionsSpec("; + out << "fieldList=" << to_string(fieldList); + out << ", " << "includeParamKeyPattern=" << to_string(includeParamKeyPattern); + out << ", " << "excludeParamKeyPattern=" << to_string(excludeParamKeyPattern); + out << ")"; +} + + +GetTableRequest::~GetTableRequest() noexcept { +} + +GetTableRequest::GetTableRequest() : dbName(), + tblName(), + catName(), + validWriteIdList(), + getColumnStats(0), + processorIdentifier(), + engine("hive"), + id(-1LL) { +} + +void GetTableRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void GetTableRequest::__set_tblName(const std::string& val) { + this->tblName = val; +} + +void GetTableRequest::__set_capabilities(const ClientCapabilities& val) { + this->capabilities = val; +__isset.capabilities = true; +} + +void GetTableRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void GetTableRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void GetTableRequest::__set_getColumnStats(const bool val) { + this->getColumnStats = val; +__isset.getColumnStats = true; +} + +void GetTableRequest::__set_processorCapabilities(const std::vector & val) { + this->processorCapabilities = val; +__isset.processorCapabilities = true; +} + +void GetTableRequest::__set_processorIdentifier(const std::string& val) { + this->processorIdentifier = val; +__isset.processorIdentifier = true; +} + +void GetTableRequest::__set_engine(const std::string& val) { + this->engine = val; +__isset.engine = true; +} + +void GetTableRequest::__set_id(const int64_t val) { + this->id = val; +__isset.id = true; +} +std::ostream& operator<<(std::ostream& out, const GetTableRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetTableRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tblName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tblName); + isset_tblName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->capabilities.read(iprot); + this->__isset.capabilities = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->getColumnStats); + this->__isset.getColumnStats = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->processorCapabilities.clear(); + uint32_t _size1323; + ::apache::thrift::protocol::TType _etype1326; + xfer += iprot->readListBegin(_etype1326, _size1323); + this->processorCapabilities.resize(_size1323); + uint32_t _i1327; + for (_i1327 = 0; _i1327 < _size1323; ++_i1327) + { + xfer += iprot->readString(this->processorCapabilities[_i1327]); + } + xfer += iprot->readListEnd(); + } + this->__isset.processorCapabilities = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->processorIdentifier); + this->__isset.processorIdentifier = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->engine); + this->__isset.engine = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 11: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->id); + this->__isset.id = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tblName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetTableRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetTableRequest"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tblName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.capabilities) { + xfer += oprot->writeFieldBegin("capabilities", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->capabilities.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.getColumnStats) { + xfer += oprot->writeFieldBegin("getColumnStats", ::apache::thrift::protocol::T_BOOL, 7); + xfer += oprot->writeBool(this->getColumnStats); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.processorCapabilities) { + xfer += oprot->writeFieldBegin("processorCapabilities", ::apache::thrift::protocol::T_LIST, 8); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->processorCapabilities.size())); + std::vector ::const_iterator _iter1328; + for (_iter1328 = this->processorCapabilities.begin(); _iter1328 != this->processorCapabilities.end(); ++_iter1328) + { + xfer += oprot->writeString((*_iter1328)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.processorIdentifier) { + xfer += oprot->writeFieldBegin("processorIdentifier", ::apache::thrift::protocol::T_STRING, 9); + xfer += oprot->writeString(this->processorIdentifier); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.engine) { + xfer += oprot->writeFieldBegin("engine", ::apache::thrift::protocol::T_STRING, 10); + xfer += oprot->writeString(this->engine); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.id) { + xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I64, 11); + xfer += oprot->writeI64(this->id); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetTableRequest &a, GetTableRequest &b) noexcept { + using ::std::swap; + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); + swap(a.capabilities, b.capabilities); + swap(a.catName, b.catName); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.getColumnStats, b.getColumnStats); + swap(a.processorCapabilities, b.processorCapabilities); + swap(a.processorIdentifier, b.processorIdentifier); + swap(a.engine, b.engine); + swap(a.id, b.id); + swap(a.__isset, b.__isset); +} + +bool GetTableRequest::operator==(const GetTableRequest & rhs) const +{ + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + if (__isset.capabilities != rhs.__isset.capabilities) + return false; + else if (__isset.capabilities && !(capabilities == rhs.capabilities)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.getColumnStats != rhs.__isset.getColumnStats) + return false; + else if (__isset.getColumnStats && !(getColumnStats == rhs.getColumnStats)) + return false; + if (__isset.processorCapabilities != rhs.__isset.processorCapabilities) + return false; + else if (__isset.processorCapabilities && !(processorCapabilities == rhs.processorCapabilities)) + return false; + if (__isset.processorIdentifier != rhs.__isset.processorIdentifier) + return false; + else if (__isset.processorIdentifier && !(processorIdentifier == rhs.processorIdentifier)) + return false; + if (__isset.engine != rhs.__isset.engine) + return false; + else if (__isset.engine && !(engine == rhs.engine)) + return false; + if (__isset.id != rhs.__isset.id) + return false; + else if (__isset.id && !(id == rhs.id)) + return false; + return true; +} + +GetTableRequest::GetTableRequest(const GetTableRequest& other1329) { + dbName = other1329.dbName; + tblName = other1329.tblName; + capabilities = other1329.capabilities; + catName = other1329.catName; + validWriteIdList = other1329.validWriteIdList; + getColumnStats = other1329.getColumnStats; + processorCapabilities = other1329.processorCapabilities; + processorIdentifier = other1329.processorIdentifier; + engine = other1329.engine; + id = other1329.id; + __isset = other1329.__isset; +} +GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other1330) { + dbName = other1330.dbName; + tblName = other1330.tblName; + capabilities = other1330.capabilities; + catName = other1330.catName; + validWriteIdList = other1330.validWriteIdList; + getColumnStats = other1330.getColumnStats; + processorCapabilities = other1330.processorCapabilities; + processorIdentifier = other1330.processorIdentifier; + engine = other1330.engine; + id = other1330.id; + __isset = other1330.__isset; + return *this; +} +void GetTableRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetTableRequest("; + out << "dbName=" << to_string(dbName); + out << ", " << "tblName=" << to_string(tblName); + out << ", " << "capabilities="; (__isset.capabilities ? (out << to_string(capabilities)) : (out << "")); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "getColumnStats="; (__isset.getColumnStats ? (out << to_string(getColumnStats)) : (out << "")); + out << ", " << "processorCapabilities="; (__isset.processorCapabilities ? (out << to_string(processorCapabilities)) : (out << "")); + out << ", " << "processorIdentifier="; (__isset.processorIdentifier ? (out << to_string(processorIdentifier)) : (out << "")); + out << ", " << "engine="; (__isset.engine ? (out << to_string(engine)) : (out << "")); + out << ", " << "id="; (__isset.id ? (out << to_string(id)) : (out << "")); + out << ")"; +} + + +GetTableResult::~GetTableResult() noexcept { +} + +GetTableResult::GetTableResult() noexcept + : isStatsCompliant(0) { +} + +void GetTableResult::__set_table(const Table& val) { + this->table = val; +} + +void GetTableResult::__set_isStatsCompliant(const bool val) { + this->isStatsCompliant = val; +__isset.isStatsCompliant = true; +} +std::ostream& operator<<(std::ostream& out, const GetTableResult& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetTableResult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_table = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->table.read(iprot); + isset_table = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isStatsCompliant); + this->__isset.isStatsCompliant = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_table) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetTableResult::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetTableResult"); + + xfer += oprot->writeFieldBegin("table", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->table.write(oprot); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.isStatsCompliant) { + xfer += oprot->writeFieldBegin("isStatsCompliant", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool(this->isStatsCompliant); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetTableResult &a, GetTableResult &b) noexcept { + using ::std::swap; + swap(a.table, b.table); + swap(a.isStatsCompliant, b.isStatsCompliant); + swap(a.__isset, b.__isset); +} + +bool GetTableResult::operator==(const GetTableResult & rhs) const +{ + if (!(table == rhs.table)) + return false; + if (__isset.isStatsCompliant != rhs.__isset.isStatsCompliant) + return false; + else if (__isset.isStatsCompliant && !(isStatsCompliant == rhs.isStatsCompliant)) + return false; + return true; +} + +GetTableResult::GetTableResult(const GetTableResult& other1331) { + table = other1331.table; + isStatsCompliant = other1331.isStatsCompliant; + __isset = other1331.__isset; +} +GetTableResult& GetTableResult::operator=(const GetTableResult& other1332) { + table = other1332.table; + isStatsCompliant = other1332.isStatsCompliant; + __isset = other1332.__isset; + return *this; +} +void GetTableResult::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetTableResult("; + out << "table=" << to_string(table); + out << ", " << "isStatsCompliant="; (__isset.isStatsCompliant ? (out << to_string(isStatsCompliant)) : (out << "")); + out << ")"; +} + + +GetTablesRequest::~GetTablesRequest() noexcept { +} + +GetTablesRequest::GetTablesRequest() noexcept + : dbName(), + catName(), + processorIdentifier(), + tablesPattern() { +} + +void GetTablesRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void GetTablesRequest::__set_tblNames(const std::vector & val) { + this->tblNames = val; +__isset.tblNames = true; +} + +void GetTablesRequest::__set_capabilities(const ClientCapabilities& val) { + this->capabilities = val; +__isset.capabilities = true; +} + +void GetTablesRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void GetTablesRequest::__set_processorCapabilities(const std::vector & val) { + this->processorCapabilities = val; +__isset.processorCapabilities = true; +} + +void GetTablesRequest::__set_processorIdentifier(const std::string& val) { + this->processorIdentifier = val; +__isset.processorIdentifier = true; +} + +void GetTablesRequest::__set_projectionSpec(const GetProjectionsSpec& val) { + this->projectionSpec = val; +__isset.projectionSpec = true; +} + +void GetTablesRequest::__set_tablesPattern(const std::string& val) { + this->tablesPattern = val; +__isset.tablesPattern = true; +} +std::ostream& operator<<(std::ostream& out, const GetTablesRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetTablesRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->tblNames.clear(); + uint32_t _size1333; + ::apache::thrift::protocol::TType _etype1336; + xfer += iprot->readListBegin(_etype1336, _size1333); + this->tblNames.resize(_size1333); + uint32_t _i1337; + for (_i1337 = 0; _i1337 < _size1333; ++_i1337) + { + xfer += iprot->readString(this->tblNames[_i1337]); + } + xfer += iprot->readListEnd(); + } + this->__isset.tblNames = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->capabilities.read(iprot); + this->__isset.capabilities = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->processorCapabilities.clear(); + uint32_t _size1338; + ::apache::thrift::protocol::TType _etype1341; + xfer += iprot->readListBegin(_etype1341, _size1338); + this->processorCapabilities.resize(_size1338); + uint32_t _i1342; + for (_i1342 = 0; _i1342 < _size1338; ++_i1342) + { + xfer += iprot->readString(this->processorCapabilities[_i1342]); + } + xfer += iprot->readListEnd(); + } + this->__isset.processorCapabilities = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->processorIdentifier); + this->__isset.processorIdentifier = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->projectionSpec.read(iprot); + this->__isset.projectionSpec = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tablesPattern); + this->__isset.tablesPattern = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetTablesRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetTablesRequest"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.tblNames) { + xfer += oprot->writeFieldBegin("tblNames", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tblNames.size())); + std::vector ::const_iterator _iter1343; + for (_iter1343 = this->tblNames.begin(); _iter1343 != this->tblNames.end(); ++_iter1343) + { + xfer += oprot->writeString((*_iter1343)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.capabilities) { + xfer += oprot->writeFieldBegin("capabilities", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->capabilities.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.processorCapabilities) { + xfer += oprot->writeFieldBegin("processorCapabilities", ::apache::thrift::protocol::T_LIST, 5); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->processorCapabilities.size())); + std::vector ::const_iterator _iter1344; + for (_iter1344 = this->processorCapabilities.begin(); _iter1344 != this->processorCapabilities.end(); ++_iter1344) + { + xfer += oprot->writeString((*_iter1344)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.processorIdentifier) { + xfer += oprot->writeFieldBegin("processorIdentifier", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->processorIdentifier); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.projectionSpec) { + xfer += oprot->writeFieldBegin("projectionSpec", ::apache::thrift::protocol::T_STRUCT, 7); + xfer += this->projectionSpec.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.tablesPattern) { + xfer += oprot->writeFieldBegin("tablesPattern", ::apache::thrift::protocol::T_STRING, 8); + xfer += oprot->writeString(this->tablesPattern); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetTablesRequest &a, GetTablesRequest &b) noexcept { + using ::std::swap; + swap(a.dbName, b.dbName); + swap(a.tblNames, b.tblNames); + swap(a.capabilities, b.capabilities); + swap(a.catName, b.catName); + swap(a.processorCapabilities, b.processorCapabilities); + swap(a.processorIdentifier, b.processorIdentifier); + swap(a.projectionSpec, b.projectionSpec); + swap(a.tablesPattern, b.tablesPattern); + swap(a.__isset, b.__isset); +} + +bool GetTablesRequest::operator==(const GetTablesRequest & rhs) const +{ + if (!(dbName == rhs.dbName)) + return false; + if (__isset.tblNames != rhs.__isset.tblNames) + return false; + else if (__isset.tblNames && !(tblNames == rhs.tblNames)) + return false; + if (__isset.capabilities != rhs.__isset.capabilities) + return false; + else if (__isset.capabilities && !(capabilities == rhs.capabilities)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (__isset.processorCapabilities != rhs.__isset.processorCapabilities) + return false; + else if (__isset.processorCapabilities && !(processorCapabilities == rhs.processorCapabilities)) + return false; + if (__isset.processorIdentifier != rhs.__isset.processorIdentifier) + return false; + else if (__isset.processorIdentifier && !(processorIdentifier == rhs.processorIdentifier)) + return false; + if (__isset.projectionSpec != rhs.__isset.projectionSpec) + return false; + else if (__isset.projectionSpec && !(projectionSpec == rhs.projectionSpec)) + return false; + if (__isset.tablesPattern != rhs.__isset.tablesPattern) + return false; + else if (__isset.tablesPattern && !(tablesPattern == rhs.tablesPattern)) + return false; + return true; +} + +GetTablesRequest::GetTablesRequest(const GetTablesRequest& other1345) { + dbName = other1345.dbName; + tblNames = other1345.tblNames; + capabilities = other1345.capabilities; + catName = other1345.catName; + processorCapabilities = other1345.processorCapabilities; + processorIdentifier = other1345.processorIdentifier; + projectionSpec = other1345.projectionSpec; + tablesPattern = other1345.tablesPattern; + __isset = other1345.__isset; +} +GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other1346) { + dbName = other1346.dbName; + tblNames = other1346.tblNames; + capabilities = other1346.capabilities; + catName = other1346.catName; + processorCapabilities = other1346.processorCapabilities; + processorIdentifier = other1346.processorIdentifier; + projectionSpec = other1346.projectionSpec; + tablesPattern = other1346.tablesPattern; + __isset = other1346.__isset; + return *this; +} +void GetTablesRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetTablesRequest("; + out << "dbName=" << to_string(dbName); + out << ", " << "tblNames="; (__isset.tblNames ? (out << to_string(tblNames)) : (out << "")); + out << ", " << "capabilities="; (__isset.capabilities ? (out << to_string(capabilities)) : (out << "")); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "processorCapabilities="; (__isset.processorCapabilities ? (out << to_string(processorCapabilities)) : (out << "")); + out << ", " << "processorIdentifier="; (__isset.processorIdentifier ? (out << to_string(processorIdentifier)) : (out << "")); + out << ", " << "projectionSpec="; (__isset.projectionSpec ? (out << to_string(projectionSpec)) : (out << "")); + out << ", " << "tablesPattern="; (__isset.tablesPattern ? (out << to_string(tablesPattern)) : (out << "")); + out << ")"; +} + + +GetTablesResult::~GetTablesResult() noexcept { +} + +GetTablesResult::GetTablesResult() noexcept { +} + +void GetTablesResult::__set_tables(const std::vector
& val) { + this->tables = val; +} +std::ostream& operator<<(std::ostream& out, const GetTablesResult& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetTablesResult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_tables = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->tables.clear(); + uint32_t _size1347; + ::apache::thrift::protocol::TType _etype1350; + xfer += iprot->readListBegin(_etype1350, _size1347); + this->tables.resize(_size1347); + uint32_t _i1351; + for (_i1351 = 0; _i1351 < _size1347; ++_i1351) + { + xfer += this->tables[_i1351].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_tables = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_tables) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetTablesResult::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetTablesResult"); + + xfer += oprot->writeFieldBegin("tables", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->tables.size())); + std::vector
::const_iterator _iter1352; + for (_iter1352 = this->tables.begin(); _iter1352 != this->tables.end(); ++_iter1352) + { + xfer += (*_iter1352).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetTablesResult &a, GetTablesResult &b) noexcept { + using ::std::swap; + swap(a.tables, b.tables); +} + +bool GetTablesResult::operator==(const GetTablesResult & rhs) const +{ + if (!(tables == rhs.tables)) + return false; + return true; +} + +GetTablesResult::GetTablesResult(const GetTablesResult& other1353) { + tables = other1353.tables; +} +GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other1354) { + tables = other1354.tables; + return *this; +} +void GetTablesResult::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetTablesResult("; + out << "tables=" << to_string(tables); + out << ")"; +} + + +GetTablesExtRequest::~GetTablesExtRequest() noexcept { +} + +GetTablesExtRequest::GetTablesExtRequest() noexcept + : catalog(), + database(), + tableNamePattern(), + requestedFields(0), + limit(0), + processorIdentifier() { +} + +void GetTablesExtRequest::__set_catalog(const std::string& val) { + this->catalog = val; +} + +void GetTablesExtRequest::__set_database(const std::string& val) { + this->database = val; +} + +void GetTablesExtRequest::__set_tableNamePattern(const std::string& val) { + this->tableNamePattern = val; +} + +void GetTablesExtRequest::__set_requestedFields(const int32_t val) { + this->requestedFields = val; +} + +void GetTablesExtRequest::__set_limit(const int32_t val) { + this->limit = val; +__isset.limit = true; +} + +void GetTablesExtRequest::__set_processorCapabilities(const std::vector & val) { + this->processorCapabilities = val; +__isset.processorCapabilities = true; +} + +void GetTablesExtRequest::__set_processorIdentifier(const std::string& val) { + this->processorIdentifier = val; +__isset.processorIdentifier = true; +} +std::ostream& operator<<(std::ostream& out, const GetTablesExtRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetTablesExtRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_catalog = false; + bool isset_database = false; + bool isset_tableNamePattern = false; + bool isset_requestedFields = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catalog); + isset_catalog = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->database); + isset_database = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableNamePattern); + isset_tableNamePattern = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->requestedFields); + isset_requestedFields = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->limit); + this->__isset.limit = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->processorCapabilities.clear(); + uint32_t _size1355; + ::apache::thrift::protocol::TType _etype1358; + xfer += iprot->readListBegin(_etype1358, _size1355); + this->processorCapabilities.resize(_size1355); + uint32_t _i1359; + for (_i1359 = 0; _i1359 < _size1355; ++_i1359) + { + xfer += iprot->readString(this->processorCapabilities[_i1359]); + } + xfer += iprot->readListEnd(); + } + this->__isset.processorCapabilities = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->processorIdentifier); + this->__isset.processorIdentifier = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_catalog) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_database) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tableNamePattern) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_requestedFields) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetTablesExtRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetTablesExtRequest"); + + xfer += oprot->writeFieldBegin("catalog", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catalog); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("database", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->database); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableNamePattern", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tableNamePattern); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("requestedFields", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32(this->requestedFields); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.limit) { + xfer += oprot->writeFieldBegin("limit", ::apache::thrift::protocol::T_I32, 5); + xfer += oprot->writeI32(this->limit); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.processorCapabilities) { + xfer += oprot->writeFieldBegin("processorCapabilities", ::apache::thrift::protocol::T_LIST, 6); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->processorCapabilities.size())); + std::vector ::const_iterator _iter1360; + for (_iter1360 = this->processorCapabilities.begin(); _iter1360 != this->processorCapabilities.end(); ++_iter1360) + { + xfer += oprot->writeString((*_iter1360)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.processorIdentifier) { + xfer += oprot->writeFieldBegin("processorIdentifier", ::apache::thrift::protocol::T_STRING, 7); + xfer += oprot->writeString(this->processorIdentifier); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetTablesExtRequest &a, GetTablesExtRequest &b) noexcept { + using ::std::swap; + swap(a.catalog, b.catalog); + swap(a.database, b.database); + swap(a.tableNamePattern, b.tableNamePattern); + swap(a.requestedFields, b.requestedFields); + swap(a.limit, b.limit); + swap(a.processorCapabilities, b.processorCapabilities); + swap(a.processorIdentifier, b.processorIdentifier); + swap(a.__isset, b.__isset); +} + +bool GetTablesExtRequest::operator==(const GetTablesExtRequest & rhs) const +{ + if (!(catalog == rhs.catalog)) + return false; + if (!(database == rhs.database)) + return false; + if (!(tableNamePattern == rhs.tableNamePattern)) + return false; + if (!(requestedFields == rhs.requestedFields)) + return false; + if (__isset.limit != rhs.__isset.limit) + return false; + else if (__isset.limit && !(limit == rhs.limit)) + return false; + if (__isset.processorCapabilities != rhs.__isset.processorCapabilities) + return false; + else if (__isset.processorCapabilities && !(processorCapabilities == rhs.processorCapabilities)) + return false; + if (__isset.processorIdentifier != rhs.__isset.processorIdentifier) + return false; + else if (__isset.processorIdentifier && !(processorIdentifier == rhs.processorIdentifier)) + return false; + return true; +} + +GetTablesExtRequest::GetTablesExtRequest(const GetTablesExtRequest& other1361) { + catalog = other1361.catalog; + database = other1361.database; + tableNamePattern = other1361.tableNamePattern; + requestedFields = other1361.requestedFields; + limit = other1361.limit; + processorCapabilities = other1361.processorCapabilities; + processorIdentifier = other1361.processorIdentifier; + __isset = other1361.__isset; +} +GetTablesExtRequest& GetTablesExtRequest::operator=(const GetTablesExtRequest& other1362) { + catalog = other1362.catalog; + database = other1362.database; + tableNamePattern = other1362.tableNamePattern; + requestedFields = other1362.requestedFields; + limit = other1362.limit; + processorCapabilities = other1362.processorCapabilities; + processorIdentifier = other1362.processorIdentifier; + __isset = other1362.__isset; + return *this; +} +void GetTablesExtRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetTablesExtRequest("; + out << "catalog=" << to_string(catalog); + out << ", " << "database=" << to_string(database); + out << ", " << "tableNamePattern=" << to_string(tableNamePattern); + out << ", " << "requestedFields=" << to_string(requestedFields); + out << ", " << "limit="; (__isset.limit ? (out << to_string(limit)) : (out << "")); + out << ", " << "processorCapabilities="; (__isset.processorCapabilities ? (out << to_string(processorCapabilities)) : (out << "")); + out << ", " << "processorIdentifier="; (__isset.processorIdentifier ? (out << to_string(processorIdentifier)) : (out << "")); + out << ")"; +} + + +ExtendedTableInfo::~ExtendedTableInfo() noexcept { +} + +ExtendedTableInfo::ExtendedTableInfo() noexcept + : tblName(), + accessType(0) { +} + +void ExtendedTableInfo::__set_tblName(const std::string& val) { + this->tblName = val; +} + +void ExtendedTableInfo::__set_accessType(const int32_t val) { + this->accessType = val; +__isset.accessType = true; +} + +void ExtendedTableInfo::__set_requiredReadCapabilities(const std::vector & val) { + this->requiredReadCapabilities = val; +__isset.requiredReadCapabilities = true; +} + +void ExtendedTableInfo::__set_requiredWriteCapabilities(const std::vector & val) { + this->requiredWriteCapabilities = val; +__isset.requiredWriteCapabilities = true; +} +std::ostream& operator<<(std::ostream& out, const ExtendedTableInfo& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ExtendedTableInfo::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_tblName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tblName); + isset_tblName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->accessType); + this->__isset.accessType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->requiredReadCapabilities.clear(); + uint32_t _size1363; + ::apache::thrift::protocol::TType _etype1366; + xfer += iprot->readListBegin(_etype1366, _size1363); + this->requiredReadCapabilities.resize(_size1363); + uint32_t _i1367; + for (_i1367 = 0; _i1367 < _size1363; ++_i1367) + { + xfer += iprot->readString(this->requiredReadCapabilities[_i1367]); + } + xfer += iprot->readListEnd(); + } + this->__isset.requiredReadCapabilities = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->requiredWriteCapabilities.clear(); + uint32_t _size1368; + ::apache::thrift::protocol::TType _etype1371; + xfer += iprot->readListBegin(_etype1371, _size1368); + this->requiredWriteCapabilities.resize(_size1368); + uint32_t _i1372; + for (_i1372 = 0; _i1372 < _size1368; ++_i1372) + { + xfer += iprot->readString(this->requiredWriteCapabilities[_i1372]); + } + xfer += iprot->readListEnd(); + } + this->__isset.requiredWriteCapabilities = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_tblName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ExtendedTableInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ExtendedTableInfo"); + + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->tblName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.accessType) { + xfer += oprot->writeFieldBegin("accessType", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(this->accessType); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.requiredReadCapabilities) { + xfer += oprot->writeFieldBegin("requiredReadCapabilities", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->requiredReadCapabilities.size())); + std::vector ::const_iterator _iter1373; + for (_iter1373 = this->requiredReadCapabilities.begin(); _iter1373 != this->requiredReadCapabilities.end(); ++_iter1373) + { + xfer += oprot->writeString((*_iter1373)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.requiredWriteCapabilities) { + xfer += oprot->writeFieldBegin("requiredWriteCapabilities", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->requiredWriteCapabilities.size())); + std::vector ::const_iterator _iter1374; + for (_iter1374 = this->requiredWriteCapabilities.begin(); _iter1374 != this->requiredWriteCapabilities.end(); ++_iter1374) + { + xfer += oprot->writeString((*_iter1374)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ExtendedTableInfo &a, ExtendedTableInfo &b) noexcept { + using ::std::swap; + swap(a.tblName, b.tblName); + swap(a.accessType, b.accessType); + swap(a.requiredReadCapabilities, b.requiredReadCapabilities); + swap(a.requiredWriteCapabilities, b.requiredWriteCapabilities); + swap(a.__isset, b.__isset); +} + +bool ExtendedTableInfo::operator==(const ExtendedTableInfo & rhs) const +{ + if (!(tblName == rhs.tblName)) + return false; + if (__isset.accessType != rhs.__isset.accessType) + return false; + else if (__isset.accessType && !(accessType == rhs.accessType)) + return false; + if (__isset.requiredReadCapabilities != rhs.__isset.requiredReadCapabilities) + return false; + else if (__isset.requiredReadCapabilities && !(requiredReadCapabilities == rhs.requiredReadCapabilities)) + return false; + if (__isset.requiredWriteCapabilities != rhs.__isset.requiredWriteCapabilities) + return false; + else if (__isset.requiredWriteCapabilities && !(requiredWriteCapabilities == rhs.requiredWriteCapabilities)) + return false; + return true; +} + +ExtendedTableInfo::ExtendedTableInfo(const ExtendedTableInfo& other1375) { + tblName = other1375.tblName; + accessType = other1375.accessType; + requiredReadCapabilities = other1375.requiredReadCapabilities; + requiredWriteCapabilities = other1375.requiredWriteCapabilities; + __isset = other1375.__isset; +} +ExtendedTableInfo& ExtendedTableInfo::operator=(const ExtendedTableInfo& other1376) { + tblName = other1376.tblName; + accessType = other1376.accessType; + requiredReadCapabilities = other1376.requiredReadCapabilities; + requiredWriteCapabilities = other1376.requiredWriteCapabilities; + __isset = other1376.__isset; + return *this; +} +void ExtendedTableInfo::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ExtendedTableInfo("; + out << "tblName=" << to_string(tblName); + out << ", " << "accessType="; (__isset.accessType ? (out << to_string(accessType)) : (out << "")); + out << ", " << "requiredReadCapabilities="; (__isset.requiredReadCapabilities ? (out << to_string(requiredReadCapabilities)) : (out << "")); + out << ", " << "requiredWriteCapabilities="; (__isset.requiredWriteCapabilities ? (out << to_string(requiredWriteCapabilities)) : (out << "")); + out << ")"; +} + + +DropTableRequest::~DropTableRequest() noexcept { +} + +DropTableRequest::DropTableRequest() noexcept + : catalogName(), + dbName(), + tableName(), + deleteData(0), + dropPartitions(0) { +} + +void DropTableRequest::__set_catalogName(const std::string& val) { + this->catalogName = val; +__isset.catalogName = true; +} + +void DropTableRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void DropTableRequest::__set_tableName(const std::string& val) { + this->tableName = val; +} + +void DropTableRequest::__set_deleteData(const bool val) { + this->deleteData = val; +__isset.deleteData = true; +} + +void DropTableRequest::__set_envContext(const EnvironmentContext& val) { + this->envContext = val; +__isset.envContext = true; +} + +void DropTableRequest::__set_dropPartitions(const bool val) { + this->dropPartitions = val; +__isset.dropPartitions = true; +} +std::ostream& operator<<(std::ostream& out, const DropTableRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t DropTableRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tableName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catalogName); + this->__isset.catalogName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + isset_tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->deleteData); + this->__isset.deleteData = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->envContext.read(iprot); + this->__isset.envContext = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->dropPartitions); + this->__isset.dropPartitions = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tableName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t DropTableRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("DropTableRequest"); + + if (this->__isset.catalogName) { + xfer += oprot->writeFieldBegin("catalogName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catalogName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.deleteData) { + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool(this->deleteData); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.envContext) { + xfer += oprot->writeFieldBegin("envContext", ::apache::thrift::protocol::T_STRUCT, 5); + xfer += this->envContext.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.dropPartitions) { + xfer += oprot->writeFieldBegin("dropPartitions", ::apache::thrift::protocol::T_BOOL, 6); + xfer += oprot->writeBool(this->dropPartitions); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(DropTableRequest &a, DropTableRequest &b) noexcept { + using ::std::swap; + swap(a.catalogName, b.catalogName); + swap(a.dbName, b.dbName); + swap(a.tableName, b.tableName); + swap(a.deleteData, b.deleteData); + swap(a.envContext, b.envContext); + swap(a.dropPartitions, b.dropPartitions); + swap(a.__isset, b.__isset); +} + +bool DropTableRequest::operator==(const DropTableRequest & rhs) const +{ + if (__isset.catalogName != rhs.__isset.catalogName) + return false; + else if (__isset.catalogName && !(catalogName == rhs.catalogName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (__isset.deleteData != rhs.__isset.deleteData) + return false; + else if (__isset.deleteData && !(deleteData == rhs.deleteData)) + return false; + if (__isset.envContext != rhs.__isset.envContext) + return false; + else if (__isset.envContext && !(envContext == rhs.envContext)) + return false; + if (__isset.dropPartitions != rhs.__isset.dropPartitions) + return false; + else if (__isset.dropPartitions && !(dropPartitions == rhs.dropPartitions)) + return false; + return true; +} + +DropTableRequest::DropTableRequest(const DropTableRequest& other1377) { + catalogName = other1377.catalogName; + dbName = other1377.dbName; + tableName = other1377.tableName; + deleteData = other1377.deleteData; + envContext = other1377.envContext; + dropPartitions = other1377.dropPartitions; + __isset = other1377.__isset; +} +DropTableRequest& DropTableRequest::operator=(const DropTableRequest& other1378) { + catalogName = other1378.catalogName; + dbName = other1378.dbName; + tableName = other1378.tableName; + deleteData = other1378.deleteData; + envContext = other1378.envContext; + dropPartitions = other1378.dropPartitions; + __isset = other1378.__isset; + return *this; +} +void DropTableRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "DropTableRequest("; + out << "catalogName="; (__isset.catalogName ? (out << to_string(catalogName)) : (out << "")); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "tableName=" << to_string(tableName); + out << ", " << "deleteData="; (__isset.deleteData ? (out << to_string(deleteData)) : (out << "")); + out << ", " << "envContext="; (__isset.envContext ? (out << to_string(envContext)) : (out << "")); + out << ", " << "dropPartitions="; (__isset.dropPartitions ? (out << to_string(dropPartitions)) : (out << "")); + out << ")"; +} + + +GetDatabaseRequest::~GetDatabaseRequest() noexcept { +} + +GetDatabaseRequest::GetDatabaseRequest() noexcept + : name(), + catalogName(), + processorIdentifier() { +} + +void GetDatabaseRequest::__set_name(const std::string& val) { + this->name = val; +__isset.name = true; +} + +void GetDatabaseRequest::__set_catalogName(const std::string& val) { + this->catalogName = val; +__isset.catalogName = true; +} + +void GetDatabaseRequest::__set_processorCapabilities(const std::vector & val) { + this->processorCapabilities = val; +__isset.processorCapabilities = true; +} + +void GetDatabaseRequest::__set_processorIdentifier(const std::string& val) { + this->processorIdentifier = val; +__isset.processorIdentifier = true; +} +std::ostream& operator<<(std::ostream& out, const GetDatabaseRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetDatabaseRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catalogName); + this->__isset.catalogName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->processorCapabilities.clear(); + uint32_t _size1379; + ::apache::thrift::protocol::TType _etype1382; + xfer += iprot->readListBegin(_etype1382, _size1379); + this->processorCapabilities.resize(_size1379); + uint32_t _i1383; + for (_i1383 = 0; _i1383 < _size1379; ++_i1383) + { + xfer += iprot->readString(this->processorCapabilities[_i1383]); + } + xfer += iprot->readListEnd(); + } + this->__isset.processorCapabilities = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->processorIdentifier); + this->__isset.processorIdentifier = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t GetDatabaseRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetDatabaseRequest"); + + if (this->__isset.name) { + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.catalogName) { + xfer += oprot->writeFieldBegin("catalogName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->catalogName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.processorCapabilities) { + xfer += oprot->writeFieldBegin("processorCapabilities", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->processorCapabilities.size())); + std::vector ::const_iterator _iter1384; + for (_iter1384 = this->processorCapabilities.begin(); _iter1384 != this->processorCapabilities.end(); ++_iter1384) + { + xfer += oprot->writeString((*_iter1384)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.processorIdentifier) { + xfer += oprot->writeFieldBegin("processorIdentifier", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->processorIdentifier); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetDatabaseRequest &a, GetDatabaseRequest &b) noexcept { + using ::std::swap; + swap(a.name, b.name); + swap(a.catalogName, b.catalogName); + swap(a.processorCapabilities, b.processorCapabilities); + swap(a.processorIdentifier, b.processorIdentifier); + swap(a.__isset, b.__isset); +} + +bool GetDatabaseRequest::operator==(const GetDatabaseRequest & rhs) const +{ + if (__isset.name != rhs.__isset.name) + return false; + else if (__isset.name && !(name == rhs.name)) + return false; + if (__isset.catalogName != rhs.__isset.catalogName) + return false; + else if (__isset.catalogName && !(catalogName == rhs.catalogName)) + return false; + if (__isset.processorCapabilities != rhs.__isset.processorCapabilities) + return false; + else if (__isset.processorCapabilities && !(processorCapabilities == rhs.processorCapabilities)) + return false; + if (__isset.processorIdentifier != rhs.__isset.processorIdentifier) + return false; + else if (__isset.processorIdentifier && !(processorIdentifier == rhs.processorIdentifier)) + return false; + return true; +} + +GetDatabaseRequest::GetDatabaseRequest(const GetDatabaseRequest& other1385) { + name = other1385.name; + catalogName = other1385.catalogName; + processorCapabilities = other1385.processorCapabilities; + processorIdentifier = other1385.processorIdentifier; + __isset = other1385.__isset; +} +GetDatabaseRequest& GetDatabaseRequest::operator=(const GetDatabaseRequest& other1386) { + name = other1386.name; + catalogName = other1386.catalogName; + processorCapabilities = other1386.processorCapabilities; + processorIdentifier = other1386.processorIdentifier; + __isset = other1386.__isset; + return *this; +} +void GetDatabaseRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetDatabaseRequest("; + out << "name="; (__isset.name ? (out << to_string(name)) : (out << "")); + out << ", " << "catalogName="; (__isset.catalogName ? (out << to_string(catalogName)) : (out << "")); + out << ", " << "processorCapabilities="; (__isset.processorCapabilities ? (out << to_string(processorCapabilities)) : (out << "")); + out << ", " << "processorIdentifier="; (__isset.processorIdentifier ? (out << to_string(processorIdentifier)) : (out << "")); + out << ")"; +} + + +AlterDatabaseRequest::~AlterDatabaseRequest() noexcept { +} + +AlterDatabaseRequest::AlterDatabaseRequest() noexcept + : oldDbName() { +} + +void AlterDatabaseRequest::__set_oldDbName(const std::string& val) { + this->oldDbName = val; +} + +void AlterDatabaseRequest::__set_newDb(const Database& val) { + this->newDb = val; +} +std::ostream& operator<<(std::ostream& out, const AlterDatabaseRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AlterDatabaseRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_oldDbName = false; + bool isset_newDb = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->oldDbName); + isset_oldDbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->newDb.read(iprot); + isset_newDb = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_oldDbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_newDb) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AlterDatabaseRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AlterDatabaseRequest"); + + xfer += oprot->writeFieldBegin("oldDbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->oldDbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("newDb", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->newDb.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AlterDatabaseRequest &a, AlterDatabaseRequest &b) noexcept { + using ::std::swap; + swap(a.oldDbName, b.oldDbName); + swap(a.newDb, b.newDb); +} + +bool AlterDatabaseRequest::operator==(const AlterDatabaseRequest & rhs) const +{ + if (!(oldDbName == rhs.oldDbName)) + return false; + if (!(newDb == rhs.newDb)) + return false; + return true; +} + +AlterDatabaseRequest::AlterDatabaseRequest(const AlterDatabaseRequest& other1387) { + oldDbName = other1387.oldDbName; + newDb = other1387.newDb; +} +AlterDatabaseRequest& AlterDatabaseRequest::operator=(const AlterDatabaseRequest& other1388) { + oldDbName = other1388.oldDbName; + newDb = other1388.newDb; + return *this; +} +void AlterDatabaseRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AlterDatabaseRequest("; + out << "oldDbName=" << to_string(oldDbName); + out << ", " << "newDb=" << to_string(newDb); + out << ")"; +} + + +DropDatabaseRequest::~DropDatabaseRequest() noexcept { +} + +DropDatabaseRequest::DropDatabaseRequest() noexcept + : name(), + catalogName(), + ignoreUnknownDb(0), + deleteData(0), + cascade(0), + softDelete(false), + txnId(0LL), + deleteManagedDir(true) { +} + +void DropDatabaseRequest::__set_name(const std::string& val) { + this->name = val; +} + +void DropDatabaseRequest::__set_catalogName(const std::string& val) { + this->catalogName = val; +__isset.catalogName = true; +} + +void DropDatabaseRequest::__set_ignoreUnknownDb(const bool val) { + this->ignoreUnknownDb = val; +} + +void DropDatabaseRequest::__set_deleteData(const bool val) { + this->deleteData = val; +} + +void DropDatabaseRequest::__set_cascade(const bool val) { + this->cascade = val; +} + +void DropDatabaseRequest::__set_softDelete(const bool val) { + this->softDelete = val; +__isset.softDelete = true; +} + +void DropDatabaseRequest::__set_txnId(const int64_t val) { + this->txnId = val; +__isset.txnId = true; +} + +void DropDatabaseRequest::__set_deleteManagedDir(const bool val) { + this->deleteManagedDir = val; +__isset.deleteManagedDir = true; +} +std::ostream& operator<<(std::ostream& out, const DropDatabaseRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t DropDatabaseRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_name = false; + bool isset_ignoreUnknownDb = false; + bool isset_deleteData = false; + bool isset_cascade = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + isset_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catalogName); + this->__isset.catalogName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->ignoreUnknownDb); + isset_ignoreUnknownDb = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->deleteData); + isset_deleteData = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->cascade); + isset_cascade = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->softDelete); + this->__isset.softDelete = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnId); + this->__isset.txnId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->deleteManagedDir); + this->__isset.deleteManagedDir = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_name) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_ignoreUnknownDb) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_deleteData) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_cascade) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t DropDatabaseRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("DropDatabaseRequest"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.catalogName) { + xfer += oprot->writeFieldBegin("catalogName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->catalogName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("ignoreUnknownDb", ::apache::thrift::protocol::T_BOOL, 3); + xfer += oprot->writeBool(this->ignoreUnknownDb); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool(this->deleteData); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("cascade", ::apache::thrift::protocol::T_BOOL, 5); + xfer += oprot->writeBool(this->cascade); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.softDelete) { + xfer += oprot->writeFieldBegin("softDelete", ::apache::thrift::protocol::T_BOOL, 6); + xfer += oprot->writeBool(this->softDelete); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.txnId) { + xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 7); + xfer += oprot->writeI64(this->txnId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.deleteManagedDir) { + xfer += oprot->writeFieldBegin("deleteManagedDir", ::apache::thrift::protocol::T_BOOL, 8); + xfer += oprot->writeBool(this->deleteManagedDir); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(DropDatabaseRequest &a, DropDatabaseRequest &b) noexcept { + using ::std::swap; + swap(a.name, b.name); + swap(a.catalogName, b.catalogName); + swap(a.ignoreUnknownDb, b.ignoreUnknownDb); + swap(a.deleteData, b.deleteData); + swap(a.cascade, b.cascade); + swap(a.softDelete, b.softDelete); + swap(a.txnId, b.txnId); + swap(a.deleteManagedDir, b.deleteManagedDir); + swap(a.__isset, b.__isset); +} + +bool DropDatabaseRequest::operator==(const DropDatabaseRequest & rhs) const +{ + if (!(name == rhs.name)) + return false; + if (__isset.catalogName != rhs.__isset.catalogName) + return false; + else if (__isset.catalogName && !(catalogName == rhs.catalogName)) + return false; + if (!(ignoreUnknownDb == rhs.ignoreUnknownDb)) + return false; + if (!(deleteData == rhs.deleteData)) + return false; + if (!(cascade == rhs.cascade)) + return false; + if (__isset.softDelete != rhs.__isset.softDelete) + return false; + else if (__isset.softDelete && !(softDelete == rhs.softDelete)) + return false; + if (__isset.txnId != rhs.__isset.txnId) + return false; + else if (__isset.txnId && !(txnId == rhs.txnId)) + return false; + if (__isset.deleteManagedDir != rhs.__isset.deleteManagedDir) + return false; + else if (__isset.deleteManagedDir && !(deleteManagedDir == rhs.deleteManagedDir)) + return false; + return true; +} + +DropDatabaseRequest::DropDatabaseRequest(const DropDatabaseRequest& other1389) { + name = other1389.name; + catalogName = other1389.catalogName; + ignoreUnknownDb = other1389.ignoreUnknownDb; + deleteData = other1389.deleteData; + cascade = other1389.cascade; + softDelete = other1389.softDelete; + txnId = other1389.txnId; + deleteManagedDir = other1389.deleteManagedDir; + __isset = other1389.__isset; +} +DropDatabaseRequest& DropDatabaseRequest::operator=(const DropDatabaseRequest& other1390) { + name = other1390.name; + catalogName = other1390.catalogName; + ignoreUnknownDb = other1390.ignoreUnknownDb; + deleteData = other1390.deleteData; + cascade = other1390.cascade; + softDelete = other1390.softDelete; + txnId = other1390.txnId; + deleteManagedDir = other1390.deleteManagedDir; + __isset = other1390.__isset; + return *this; +} +void DropDatabaseRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "DropDatabaseRequest("; + out << "name=" << to_string(name); + out << ", " << "catalogName="; (__isset.catalogName ? (out << to_string(catalogName)) : (out << "")); + out << ", " << "ignoreUnknownDb=" << to_string(ignoreUnknownDb); + out << ", " << "deleteData=" << to_string(deleteData); + out << ", " << "cascade=" << to_string(cascade); + out << ", " << "softDelete="; (__isset.softDelete ? (out << to_string(softDelete)) : (out << "")); + out << ", " << "txnId="; (__isset.txnId ? (out << to_string(txnId)) : (out << "")); + out << ", " << "deleteManagedDir="; (__isset.deleteManagedDir ? (out << to_string(deleteManagedDir)) : (out << "")); + out << ")"; +} + + +CmRecycleRequest::~CmRecycleRequest() noexcept { +} + +CmRecycleRequest::CmRecycleRequest() noexcept + : dataPath(), + purge(0) { +} + +void CmRecycleRequest::__set_dataPath(const std::string& val) { + this->dataPath = val; +} + +void CmRecycleRequest::__set_purge(const bool val) { + this->purge = val; +} +std::ostream& operator<<(std::ostream& out, const CmRecycleRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t CmRecycleRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dataPath = false; + bool isset_purge = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dataPath); + isset_dataPath = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->purge); + isset_purge = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dataPath) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_purge) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t CmRecycleRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CmRecycleRequest"); + + xfer += oprot->writeFieldBegin("dataPath", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dataPath); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("purge", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool(this->purge); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CmRecycleRequest &a, CmRecycleRequest &b) noexcept { + using ::std::swap; + swap(a.dataPath, b.dataPath); + swap(a.purge, b.purge); +} + +bool CmRecycleRequest::operator==(const CmRecycleRequest & rhs) const +{ + if (!(dataPath == rhs.dataPath)) + return false; + if (!(purge == rhs.purge)) + return false; + return true; +} + +CmRecycleRequest::CmRecycleRequest(const CmRecycleRequest& other1391) { + dataPath = other1391.dataPath; + purge = other1391.purge; +} +CmRecycleRequest& CmRecycleRequest::operator=(const CmRecycleRequest& other1392) { + dataPath = other1392.dataPath; + purge = other1392.purge; + return *this; +} +void CmRecycleRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CmRecycleRequest("; + out << "dataPath=" << to_string(dataPath); + out << ", " << "purge=" << to_string(purge); + out << ")"; +} + + +CmRecycleResponse::~CmRecycleResponse() noexcept { +} + +CmRecycleResponse::CmRecycleResponse() noexcept { +} +std::ostream& operator<<(std::ostream& out, const CmRecycleResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t CmRecycleResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t CmRecycleResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CmRecycleResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CmRecycleResponse &a, CmRecycleResponse &b) noexcept { + using ::std::swap; + (void) a; + (void) b; +} + +bool CmRecycleResponse::operator==(const CmRecycleResponse & /* rhs */) const +{ + return true; +} + +CmRecycleResponse::CmRecycleResponse(const CmRecycleResponse& other1393) noexcept { + (void) other1393; +} +CmRecycleResponse& CmRecycleResponse::operator=(const CmRecycleResponse& other1394) noexcept { + (void) other1394; + return *this; +} +void CmRecycleResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CmRecycleResponse("; + out << ")"; +} + + +TableMeta::~TableMeta() noexcept { +} + +TableMeta::TableMeta() noexcept + : dbName(), + tableName(), + tableType(), + comments(), + catName(), + ownerName(), + ownerType(static_cast(0)) { +} + +void TableMeta::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void TableMeta::__set_tableName(const std::string& val) { + this->tableName = val; +} + +void TableMeta::__set_tableType(const std::string& val) { + this->tableType = val; +} + +void TableMeta::__set_comments(const std::string& val) { + this->comments = val; +__isset.comments = true; +} + +void TableMeta::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void TableMeta::__set_ownerName(const std::string& val) { + this->ownerName = val; +__isset.ownerName = true; +} + +void TableMeta::__set_ownerType(const PrincipalType::type val) { + this->ownerType = val; +__isset.ownerType = true; +} +std::ostream& operator<<(std::ostream& out, const TableMeta& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t TableMeta::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tableName = false; + bool isset_tableType = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + isset_tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableType); + isset_tableType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->comments); + this->__isset.comments = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ownerName); + this->__isset.ownerName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1395; + xfer += iprot->readI32(ecast1395); + this->ownerType = static_cast(ecast1395); + this->__isset.ownerType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tableName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tableType) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t TableMeta::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("TableMeta"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableType", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tableType); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.comments) { + xfer += oprot->writeFieldBegin("comments", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->comments); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ownerName) { + xfer += oprot->writeFieldBegin("ownerName", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->ownerName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ownerType) { + xfer += oprot->writeFieldBegin("ownerType", ::apache::thrift::protocol::T_I32, 7); + xfer += oprot->writeI32(static_cast(this->ownerType)); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(TableMeta &a, TableMeta &b) noexcept { + using ::std::swap; + swap(a.dbName, b.dbName); + swap(a.tableName, b.tableName); + swap(a.tableType, b.tableType); + swap(a.comments, b.comments); + swap(a.catName, b.catName); + swap(a.ownerName, b.ownerName); + swap(a.ownerType, b.ownerType); + swap(a.__isset, b.__isset); +} + +bool TableMeta::operator==(const TableMeta & rhs) const +{ + if (!(dbName == rhs.dbName)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(tableType == rhs.tableType)) + return false; + if (__isset.comments != rhs.__isset.comments) + return false; + else if (__isset.comments && !(comments == rhs.comments)) + return false; + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (__isset.ownerName != rhs.__isset.ownerName) + return false; + else if (__isset.ownerName && !(ownerName == rhs.ownerName)) + return false; + if (__isset.ownerType != rhs.__isset.ownerType) + return false; + else if (__isset.ownerType && !(ownerType == rhs.ownerType)) + return false; + return true; +} + +TableMeta::TableMeta(const TableMeta& other1396) { + dbName = other1396.dbName; + tableName = other1396.tableName; + tableType = other1396.tableType; + comments = other1396.comments; + catName = other1396.catName; + ownerName = other1396.ownerName; + ownerType = other1396.ownerType; + __isset = other1396.__isset; +} +TableMeta& TableMeta::operator=(const TableMeta& other1397) { + dbName = other1397.dbName; + tableName = other1397.tableName; + tableType = other1397.tableType; + comments = other1397.comments; + catName = other1397.catName; + ownerName = other1397.ownerName; + ownerType = other1397.ownerType; + __isset = other1397.__isset; + return *this; +} +void TableMeta::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "TableMeta("; + out << "dbName=" << to_string(dbName); + out << ", " << "tableName=" << to_string(tableName); + out << ", " << "tableType=" << to_string(tableType); + out << ", " << "comments="; (__isset.comments ? (out << to_string(comments)) : (out << "")); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "ownerName="; (__isset.ownerName ? (out << to_string(ownerName)) : (out << "")); + out << ", " << "ownerType="; (__isset.ownerType ? (out << to_string(ownerType)) : (out << "")); + out << ")"; +} + + +Materialization::~Materialization() noexcept { +} + +Materialization::Materialization() noexcept + : sourceTablesUpdateDeleteModified(0), + sourceTablesCompacted(0) { +} + +void Materialization::__set_sourceTablesUpdateDeleteModified(const bool val) { + this->sourceTablesUpdateDeleteModified = val; +} + +void Materialization::__set_sourceTablesCompacted(const bool val) { + this->sourceTablesCompacted = val; +} +std::ostream& operator<<(std::ostream& out, const Materialization& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Materialization::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_sourceTablesUpdateDeleteModified = false; + bool isset_sourceTablesCompacted = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->sourceTablesUpdateDeleteModified); + isset_sourceTablesUpdateDeleteModified = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->sourceTablesCompacted); + isset_sourceTablesCompacted = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_sourceTablesUpdateDeleteModified) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_sourceTablesCompacted) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Materialization::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Materialization"); + + xfer += oprot->writeFieldBegin("sourceTablesUpdateDeleteModified", ::apache::thrift::protocol::T_BOOL, 1); + xfer += oprot->writeBool(this->sourceTablesUpdateDeleteModified); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("sourceTablesCompacted", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool(this->sourceTablesCompacted); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Materialization &a, Materialization &b) noexcept { + using ::std::swap; + swap(a.sourceTablesUpdateDeleteModified, b.sourceTablesUpdateDeleteModified); + swap(a.sourceTablesCompacted, b.sourceTablesCompacted); +} + +bool Materialization::operator==(const Materialization & rhs) const +{ + if (!(sourceTablesUpdateDeleteModified == rhs.sourceTablesUpdateDeleteModified)) + return false; + if (!(sourceTablesCompacted == rhs.sourceTablesCompacted)) + return false; + return true; +} + +Materialization::Materialization(const Materialization& other1398) noexcept { + sourceTablesUpdateDeleteModified = other1398.sourceTablesUpdateDeleteModified; + sourceTablesCompacted = other1398.sourceTablesCompacted; +} +Materialization& Materialization::operator=(const Materialization& other1399) noexcept { + sourceTablesUpdateDeleteModified = other1399.sourceTablesUpdateDeleteModified; + sourceTablesCompacted = other1399.sourceTablesCompacted; + return *this; +} +void Materialization::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Materialization("; + out << "sourceTablesUpdateDeleteModified=" << to_string(sourceTablesUpdateDeleteModified); + out << ", " << "sourceTablesCompacted=" << to_string(sourceTablesCompacted); + out << ")"; +} + + +WMResourcePlan::~WMResourcePlan() noexcept { +} + +WMResourcePlan::WMResourcePlan() noexcept + : name(), + status(static_cast(0)), + queryParallelism(0), + defaultPoolPath(), + ns() { +} + +void WMResourcePlan::__set_name(const std::string& val) { + this->name = val; +} + +void WMResourcePlan::__set_status(const WMResourcePlanStatus::type val) { + this->status = val; +__isset.status = true; +} + +void WMResourcePlan::__set_queryParallelism(const int32_t val) { + this->queryParallelism = val; +__isset.queryParallelism = true; +} + +void WMResourcePlan::__set_defaultPoolPath(const std::string& val) { + this->defaultPoolPath = val; +__isset.defaultPoolPath = true; +} + +void WMResourcePlan::__set_ns(const std::string& val) { + this->ns = val; +__isset.ns = true; +} +std::ostream& operator<<(std::ostream& out, const WMResourcePlan& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_name = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + isset_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1400; + xfer += iprot->readI32(ecast1400); + this->status = static_cast(ecast1400); + this->__isset.status = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->queryParallelism); + this->__isset.queryParallelism = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->defaultPoolPath); + this->__isset.defaultPoolPath = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ns); + this->__isset.ns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_name) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t WMResourcePlan::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMResourcePlan"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.status) { + xfer += oprot->writeFieldBegin("status", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(static_cast(this->status)); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.queryParallelism) { + xfer += oprot->writeFieldBegin("queryParallelism", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32(this->queryParallelism); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.defaultPoolPath) { + xfer += oprot->writeFieldBegin("defaultPoolPath", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->defaultPoolPath); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ns) { + xfer += oprot->writeFieldBegin("ns", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->ns); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMResourcePlan &a, WMResourcePlan &b) noexcept { + using ::std::swap; + swap(a.name, b.name); + swap(a.status, b.status); + swap(a.queryParallelism, b.queryParallelism); + swap(a.defaultPoolPath, b.defaultPoolPath); + swap(a.ns, b.ns); + swap(a.__isset, b.__isset); +} + +bool WMResourcePlan::operator==(const WMResourcePlan & rhs) const +{ + if (!(name == rhs.name)) + return false; + if (__isset.status != rhs.__isset.status) + return false; + else if (__isset.status && !(status == rhs.status)) + return false; + if (__isset.queryParallelism != rhs.__isset.queryParallelism) + return false; + else if (__isset.queryParallelism && !(queryParallelism == rhs.queryParallelism)) + return false; + if (__isset.defaultPoolPath != rhs.__isset.defaultPoolPath) + return false; + else if (__isset.defaultPoolPath && !(defaultPoolPath == rhs.defaultPoolPath)) + return false; + if (__isset.ns != rhs.__isset.ns) + return false; + else if (__isset.ns && !(ns == rhs.ns)) + return false; + return true; +} + +WMResourcePlan::WMResourcePlan(const WMResourcePlan& other1401) { + name = other1401.name; + status = other1401.status; + queryParallelism = other1401.queryParallelism; + defaultPoolPath = other1401.defaultPoolPath; + ns = other1401.ns; + __isset = other1401.__isset; +} +WMResourcePlan& WMResourcePlan::operator=(const WMResourcePlan& other1402) { + name = other1402.name; + status = other1402.status; + queryParallelism = other1402.queryParallelism; + defaultPoolPath = other1402.defaultPoolPath; + ns = other1402.ns; + __isset = other1402.__isset; + return *this; +} +void WMResourcePlan::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMResourcePlan("; + out << "name=" << to_string(name); + out << ", " << "status="; (__isset.status ? (out << to_string(status)) : (out << "")); + out << ", " << "queryParallelism="; (__isset.queryParallelism ? (out << to_string(queryParallelism)) : (out << "")); + out << ", " << "defaultPoolPath="; (__isset.defaultPoolPath ? (out << to_string(defaultPoolPath)) : (out << "")); + out << ", " << "ns="; (__isset.ns ? (out << to_string(ns)) : (out << "")); + out << ")"; +} + + +WMNullableResourcePlan::~WMNullableResourcePlan() noexcept { +} + +WMNullableResourcePlan::WMNullableResourcePlan() noexcept + : name(), + status(static_cast(0)), + queryParallelism(0), + isSetQueryParallelism(0), + defaultPoolPath(), + isSetDefaultPoolPath(0), + ns() { +} + +void WMNullableResourcePlan::__set_name(const std::string& val) { + this->name = val; +__isset.name = true; +} + +void WMNullableResourcePlan::__set_status(const WMResourcePlanStatus::type val) { + this->status = val; +__isset.status = true; +} + +void WMNullableResourcePlan::__set_queryParallelism(const int32_t val) { + this->queryParallelism = val; +__isset.queryParallelism = true; +} + +void WMNullableResourcePlan::__set_isSetQueryParallelism(const bool val) { + this->isSetQueryParallelism = val; +__isset.isSetQueryParallelism = true; +} + +void WMNullableResourcePlan::__set_defaultPoolPath(const std::string& val) { + this->defaultPoolPath = val; +__isset.defaultPoolPath = true; +} + +void WMNullableResourcePlan::__set_isSetDefaultPoolPath(const bool val) { + this->isSetDefaultPoolPath = val; +__isset.isSetDefaultPoolPath = true; +} + +void WMNullableResourcePlan::__set_ns(const std::string& val) { + this->ns = val; +__isset.ns = true; +} +std::ostream& operator<<(std::ostream& out, const WMNullableResourcePlan& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMNullableResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1403; + xfer += iprot->readI32(ecast1403); + this->status = static_cast(ecast1403); + this->__isset.status = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->queryParallelism); + this->__isset.queryParallelism = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isSetQueryParallelism); + this->__isset.isSetQueryParallelism = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->defaultPoolPath); + this->__isset.defaultPoolPath = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isSetDefaultPoolPath); + this->__isset.isSetDefaultPoolPath = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ns); + this->__isset.ns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMNullableResourcePlan::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMNullableResourcePlan"); + + if (this->__isset.name) { + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.status) { + xfer += oprot->writeFieldBegin("status", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(static_cast(this->status)); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.queryParallelism) { + xfer += oprot->writeFieldBegin("queryParallelism", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32(this->queryParallelism); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.isSetQueryParallelism) { + xfer += oprot->writeFieldBegin("isSetQueryParallelism", ::apache::thrift::protocol::T_BOOL, 5); + xfer += oprot->writeBool(this->isSetQueryParallelism); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.defaultPoolPath) { + xfer += oprot->writeFieldBegin("defaultPoolPath", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->defaultPoolPath); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.isSetDefaultPoolPath) { + xfer += oprot->writeFieldBegin("isSetDefaultPoolPath", ::apache::thrift::protocol::T_BOOL, 7); + xfer += oprot->writeBool(this->isSetDefaultPoolPath); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ns) { + xfer += oprot->writeFieldBegin("ns", ::apache::thrift::protocol::T_STRING, 8); + xfer += oprot->writeString(this->ns); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMNullableResourcePlan &a, WMNullableResourcePlan &b) noexcept { + using ::std::swap; + swap(a.name, b.name); + swap(a.status, b.status); + swap(a.queryParallelism, b.queryParallelism); + swap(a.isSetQueryParallelism, b.isSetQueryParallelism); + swap(a.defaultPoolPath, b.defaultPoolPath); + swap(a.isSetDefaultPoolPath, b.isSetDefaultPoolPath); + swap(a.ns, b.ns); + swap(a.__isset, b.__isset); +} + +bool WMNullableResourcePlan::operator==(const WMNullableResourcePlan & rhs) const +{ + if (__isset.name != rhs.__isset.name) + return false; + else if (__isset.name && !(name == rhs.name)) + return false; + if (__isset.status != rhs.__isset.status) + return false; + else if (__isset.status && !(status == rhs.status)) + return false; + if (__isset.queryParallelism != rhs.__isset.queryParallelism) + return false; + else if (__isset.queryParallelism && !(queryParallelism == rhs.queryParallelism)) + return false; + if (__isset.isSetQueryParallelism != rhs.__isset.isSetQueryParallelism) + return false; + else if (__isset.isSetQueryParallelism && !(isSetQueryParallelism == rhs.isSetQueryParallelism)) + return false; + if (__isset.defaultPoolPath != rhs.__isset.defaultPoolPath) + return false; + else if (__isset.defaultPoolPath && !(defaultPoolPath == rhs.defaultPoolPath)) + return false; + if (__isset.isSetDefaultPoolPath != rhs.__isset.isSetDefaultPoolPath) + return false; + else if (__isset.isSetDefaultPoolPath && !(isSetDefaultPoolPath == rhs.isSetDefaultPoolPath)) + return false; + if (__isset.ns != rhs.__isset.ns) + return false; + else if (__isset.ns && !(ns == rhs.ns)) + return false; + return true; +} + +WMNullableResourcePlan::WMNullableResourcePlan(const WMNullableResourcePlan& other1404) { + name = other1404.name; + status = other1404.status; + queryParallelism = other1404.queryParallelism; + isSetQueryParallelism = other1404.isSetQueryParallelism; + defaultPoolPath = other1404.defaultPoolPath; + isSetDefaultPoolPath = other1404.isSetDefaultPoolPath; + ns = other1404.ns; + __isset = other1404.__isset; +} +WMNullableResourcePlan& WMNullableResourcePlan::operator=(const WMNullableResourcePlan& other1405) { + name = other1405.name; + status = other1405.status; + queryParallelism = other1405.queryParallelism; + isSetQueryParallelism = other1405.isSetQueryParallelism; + defaultPoolPath = other1405.defaultPoolPath; + isSetDefaultPoolPath = other1405.isSetDefaultPoolPath; + ns = other1405.ns; + __isset = other1405.__isset; + return *this; +} +void WMNullableResourcePlan::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMNullableResourcePlan("; + out << "name="; (__isset.name ? (out << to_string(name)) : (out << "")); + out << ", " << "status="; (__isset.status ? (out << to_string(status)) : (out << "")); + out << ", " << "queryParallelism="; (__isset.queryParallelism ? (out << to_string(queryParallelism)) : (out << "")); + out << ", " << "isSetQueryParallelism="; (__isset.isSetQueryParallelism ? (out << to_string(isSetQueryParallelism)) : (out << "")); + out << ", " << "defaultPoolPath="; (__isset.defaultPoolPath ? (out << to_string(defaultPoolPath)) : (out << "")); + out << ", " << "isSetDefaultPoolPath="; (__isset.isSetDefaultPoolPath ? (out << to_string(isSetDefaultPoolPath)) : (out << "")); + out << ", " << "ns="; (__isset.ns ? (out << to_string(ns)) : (out << "")); + out << ")"; +} + + +WMPool::~WMPool() noexcept { +} + +WMPool::WMPool() noexcept + : resourcePlanName(), + poolPath(), + allocFraction(0), + queryParallelism(0), + schedulingPolicy(), + ns() { +} + +void WMPool::__set_resourcePlanName(const std::string& val) { + this->resourcePlanName = val; +} + +void WMPool::__set_poolPath(const std::string& val) { + this->poolPath = val; +} + +void WMPool::__set_allocFraction(const double val) { + this->allocFraction = val; +__isset.allocFraction = true; +} + +void WMPool::__set_queryParallelism(const int32_t val) { + this->queryParallelism = val; +__isset.queryParallelism = true; +} + +void WMPool::__set_schedulingPolicy(const std::string& val) { + this->schedulingPolicy = val; +__isset.schedulingPolicy = true; +} + +void WMPool::__set_ns(const std::string& val) { + this->ns = val; +__isset.ns = true; +} +std::ostream& operator<<(std::ostream& out, const WMPool& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMPool::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_resourcePlanName = false; + bool isset_poolPath = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->resourcePlanName); + isset_resourcePlanName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->poolPath); + isset_poolPath = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_DOUBLE) { + xfer += iprot->readDouble(this->allocFraction); + this->__isset.allocFraction = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->queryParallelism); + this->__isset.queryParallelism = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->schedulingPolicy); + this->__isset.schedulingPolicy = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ns); + this->__isset.ns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_resourcePlanName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_poolPath) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t WMPool::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMPool"); + + xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->resourcePlanName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("poolPath", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->poolPath); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.allocFraction) { + xfer += oprot->writeFieldBegin("allocFraction", ::apache::thrift::protocol::T_DOUBLE, 3); + xfer += oprot->writeDouble(this->allocFraction); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.queryParallelism) { + xfer += oprot->writeFieldBegin("queryParallelism", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32(this->queryParallelism); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.schedulingPolicy) { + xfer += oprot->writeFieldBegin("schedulingPolicy", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->schedulingPolicy); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ns) { + xfer += oprot->writeFieldBegin("ns", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->ns); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMPool &a, WMPool &b) noexcept { + using ::std::swap; + swap(a.resourcePlanName, b.resourcePlanName); + swap(a.poolPath, b.poolPath); + swap(a.allocFraction, b.allocFraction); + swap(a.queryParallelism, b.queryParallelism); + swap(a.schedulingPolicy, b.schedulingPolicy); + swap(a.ns, b.ns); + swap(a.__isset, b.__isset); +} + +bool WMPool::operator==(const WMPool & rhs) const +{ + if (!(resourcePlanName == rhs.resourcePlanName)) + return false; + if (!(poolPath == rhs.poolPath)) + return false; + if (__isset.allocFraction != rhs.__isset.allocFraction) + return false; + else if (__isset.allocFraction && !(allocFraction == rhs.allocFraction)) + return false; + if (__isset.queryParallelism != rhs.__isset.queryParallelism) + return false; + else if (__isset.queryParallelism && !(queryParallelism == rhs.queryParallelism)) + return false; + if (__isset.schedulingPolicy != rhs.__isset.schedulingPolicy) + return false; + else if (__isset.schedulingPolicy && !(schedulingPolicy == rhs.schedulingPolicy)) + return false; + if (__isset.ns != rhs.__isset.ns) + return false; + else if (__isset.ns && !(ns == rhs.ns)) + return false; + return true; +} + +WMPool::WMPool(const WMPool& other1406) { + resourcePlanName = other1406.resourcePlanName; + poolPath = other1406.poolPath; + allocFraction = other1406.allocFraction; + queryParallelism = other1406.queryParallelism; + schedulingPolicy = other1406.schedulingPolicy; + ns = other1406.ns; + __isset = other1406.__isset; +} +WMPool& WMPool::operator=(const WMPool& other1407) { + resourcePlanName = other1407.resourcePlanName; + poolPath = other1407.poolPath; + allocFraction = other1407.allocFraction; + queryParallelism = other1407.queryParallelism; + schedulingPolicy = other1407.schedulingPolicy; + ns = other1407.ns; + __isset = other1407.__isset; + return *this; +} +void WMPool::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMPool("; + out << "resourcePlanName=" << to_string(resourcePlanName); + out << ", " << "poolPath=" << to_string(poolPath); + out << ", " << "allocFraction="; (__isset.allocFraction ? (out << to_string(allocFraction)) : (out << "")); + out << ", " << "queryParallelism="; (__isset.queryParallelism ? (out << to_string(queryParallelism)) : (out << "")); + out << ", " << "schedulingPolicy="; (__isset.schedulingPolicy ? (out << to_string(schedulingPolicy)) : (out << "")); + out << ", " << "ns="; (__isset.ns ? (out << to_string(ns)) : (out << "")); + out << ")"; +} + + +WMNullablePool::~WMNullablePool() noexcept { +} + +WMNullablePool::WMNullablePool() noexcept + : resourcePlanName(), + poolPath(), + allocFraction(0), + queryParallelism(0), + schedulingPolicy(), + isSetSchedulingPolicy(0), + ns() { +} + +void WMNullablePool::__set_resourcePlanName(const std::string& val) { + this->resourcePlanName = val; +} + +void WMNullablePool::__set_poolPath(const std::string& val) { + this->poolPath = val; +} + +void WMNullablePool::__set_allocFraction(const double val) { + this->allocFraction = val; +__isset.allocFraction = true; +} + +void WMNullablePool::__set_queryParallelism(const int32_t val) { + this->queryParallelism = val; +__isset.queryParallelism = true; +} + +void WMNullablePool::__set_schedulingPolicy(const std::string& val) { + this->schedulingPolicy = val; +__isset.schedulingPolicy = true; +} + +void WMNullablePool::__set_isSetSchedulingPolicy(const bool val) { + this->isSetSchedulingPolicy = val; +__isset.isSetSchedulingPolicy = true; +} + +void WMNullablePool::__set_ns(const std::string& val) { + this->ns = val; +__isset.ns = true; +} +std::ostream& operator<<(std::ostream& out, const WMNullablePool& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMNullablePool::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_resourcePlanName = false; + bool isset_poolPath = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->resourcePlanName); + isset_resourcePlanName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->poolPath); + isset_poolPath = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_DOUBLE) { + xfer += iprot->readDouble(this->allocFraction); + this->__isset.allocFraction = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->queryParallelism); + this->__isset.queryParallelism = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->schedulingPolicy); + this->__isset.schedulingPolicy = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isSetSchedulingPolicy); + this->__isset.isSetSchedulingPolicy = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ns); + this->__isset.ns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_resourcePlanName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_poolPath) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t WMNullablePool::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMNullablePool"); + + xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->resourcePlanName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("poolPath", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->poolPath); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.allocFraction) { + xfer += oprot->writeFieldBegin("allocFraction", ::apache::thrift::protocol::T_DOUBLE, 3); + xfer += oprot->writeDouble(this->allocFraction); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.queryParallelism) { + xfer += oprot->writeFieldBegin("queryParallelism", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32(this->queryParallelism); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.schedulingPolicy) { + xfer += oprot->writeFieldBegin("schedulingPolicy", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->schedulingPolicy); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.isSetSchedulingPolicy) { + xfer += oprot->writeFieldBegin("isSetSchedulingPolicy", ::apache::thrift::protocol::T_BOOL, 6); + xfer += oprot->writeBool(this->isSetSchedulingPolicy); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ns) { + xfer += oprot->writeFieldBegin("ns", ::apache::thrift::protocol::T_STRING, 7); + xfer += oprot->writeString(this->ns); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMNullablePool &a, WMNullablePool &b) noexcept { + using ::std::swap; + swap(a.resourcePlanName, b.resourcePlanName); + swap(a.poolPath, b.poolPath); + swap(a.allocFraction, b.allocFraction); + swap(a.queryParallelism, b.queryParallelism); + swap(a.schedulingPolicy, b.schedulingPolicy); + swap(a.isSetSchedulingPolicy, b.isSetSchedulingPolicy); + swap(a.ns, b.ns); + swap(a.__isset, b.__isset); +} + +bool WMNullablePool::operator==(const WMNullablePool & rhs) const +{ + if (!(resourcePlanName == rhs.resourcePlanName)) + return false; + if (!(poolPath == rhs.poolPath)) + return false; + if (__isset.allocFraction != rhs.__isset.allocFraction) + return false; + else if (__isset.allocFraction && !(allocFraction == rhs.allocFraction)) + return false; + if (__isset.queryParallelism != rhs.__isset.queryParallelism) + return false; + else if (__isset.queryParallelism && !(queryParallelism == rhs.queryParallelism)) + return false; + if (__isset.schedulingPolicy != rhs.__isset.schedulingPolicy) + return false; + else if (__isset.schedulingPolicy && !(schedulingPolicy == rhs.schedulingPolicy)) + return false; + if (__isset.isSetSchedulingPolicy != rhs.__isset.isSetSchedulingPolicy) + return false; + else if (__isset.isSetSchedulingPolicy && !(isSetSchedulingPolicy == rhs.isSetSchedulingPolicy)) + return false; + if (__isset.ns != rhs.__isset.ns) + return false; + else if (__isset.ns && !(ns == rhs.ns)) + return false; + return true; +} + +WMNullablePool::WMNullablePool(const WMNullablePool& other1408) { + resourcePlanName = other1408.resourcePlanName; + poolPath = other1408.poolPath; + allocFraction = other1408.allocFraction; + queryParallelism = other1408.queryParallelism; + schedulingPolicy = other1408.schedulingPolicy; + isSetSchedulingPolicy = other1408.isSetSchedulingPolicy; + ns = other1408.ns; + __isset = other1408.__isset; +} +WMNullablePool& WMNullablePool::operator=(const WMNullablePool& other1409) { + resourcePlanName = other1409.resourcePlanName; + poolPath = other1409.poolPath; + allocFraction = other1409.allocFraction; + queryParallelism = other1409.queryParallelism; + schedulingPolicy = other1409.schedulingPolicy; + isSetSchedulingPolicy = other1409.isSetSchedulingPolicy; + ns = other1409.ns; + __isset = other1409.__isset; + return *this; +} +void WMNullablePool::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMNullablePool("; + out << "resourcePlanName=" << to_string(resourcePlanName); + out << ", " << "poolPath=" << to_string(poolPath); + out << ", " << "allocFraction="; (__isset.allocFraction ? (out << to_string(allocFraction)) : (out << "")); + out << ", " << "queryParallelism="; (__isset.queryParallelism ? (out << to_string(queryParallelism)) : (out << "")); + out << ", " << "schedulingPolicy="; (__isset.schedulingPolicy ? (out << to_string(schedulingPolicy)) : (out << "")); + out << ", " << "isSetSchedulingPolicy="; (__isset.isSetSchedulingPolicy ? (out << to_string(isSetSchedulingPolicy)) : (out << "")); + out << ", " << "ns="; (__isset.ns ? (out << to_string(ns)) : (out << "")); + out << ")"; +} + + +WMTrigger::~WMTrigger() noexcept { +} + +WMTrigger::WMTrigger() noexcept + : resourcePlanName(), + triggerName(), + triggerExpression(), + actionExpression(), + isInUnmanaged(0), + ns() { +} + +void WMTrigger::__set_resourcePlanName(const std::string& val) { + this->resourcePlanName = val; +} + +void WMTrigger::__set_triggerName(const std::string& val) { + this->triggerName = val; +} + +void WMTrigger::__set_triggerExpression(const std::string& val) { + this->triggerExpression = val; +__isset.triggerExpression = true; +} + +void WMTrigger::__set_actionExpression(const std::string& val) { + this->actionExpression = val; +__isset.actionExpression = true; +} + +void WMTrigger::__set_isInUnmanaged(const bool val) { + this->isInUnmanaged = val; +__isset.isInUnmanaged = true; +} + +void WMTrigger::__set_ns(const std::string& val) { + this->ns = val; +__isset.ns = true; +} +std::ostream& operator<<(std::ostream& out, const WMTrigger& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMTrigger::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_resourcePlanName = false; + bool isset_triggerName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->resourcePlanName); + isset_resourcePlanName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->triggerName); + isset_triggerName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->triggerExpression); + this->__isset.triggerExpression = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->actionExpression); + this->__isset.actionExpression = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isInUnmanaged); + this->__isset.isInUnmanaged = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ns); + this->__isset.ns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_resourcePlanName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_triggerName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t WMTrigger::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMTrigger"); + + xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->resourcePlanName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("triggerName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->triggerName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.triggerExpression) { + xfer += oprot->writeFieldBegin("triggerExpression", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->triggerExpression); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.actionExpression) { + xfer += oprot->writeFieldBegin("actionExpression", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->actionExpression); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.isInUnmanaged) { + xfer += oprot->writeFieldBegin("isInUnmanaged", ::apache::thrift::protocol::T_BOOL, 5); + xfer += oprot->writeBool(this->isInUnmanaged); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ns) { + xfer += oprot->writeFieldBegin("ns", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->ns); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMTrigger &a, WMTrigger &b) noexcept { + using ::std::swap; + swap(a.resourcePlanName, b.resourcePlanName); + swap(a.triggerName, b.triggerName); + swap(a.triggerExpression, b.triggerExpression); + swap(a.actionExpression, b.actionExpression); + swap(a.isInUnmanaged, b.isInUnmanaged); + swap(a.ns, b.ns); + swap(a.__isset, b.__isset); +} + +bool WMTrigger::operator==(const WMTrigger & rhs) const +{ + if (!(resourcePlanName == rhs.resourcePlanName)) + return false; + if (!(triggerName == rhs.triggerName)) + return false; + if (__isset.triggerExpression != rhs.__isset.triggerExpression) + return false; + else if (__isset.triggerExpression && !(triggerExpression == rhs.triggerExpression)) + return false; + if (__isset.actionExpression != rhs.__isset.actionExpression) + return false; + else if (__isset.actionExpression && !(actionExpression == rhs.actionExpression)) + return false; + if (__isset.isInUnmanaged != rhs.__isset.isInUnmanaged) + return false; + else if (__isset.isInUnmanaged && !(isInUnmanaged == rhs.isInUnmanaged)) + return false; + if (__isset.ns != rhs.__isset.ns) + return false; + else if (__isset.ns && !(ns == rhs.ns)) + return false; + return true; +} + +WMTrigger::WMTrigger(const WMTrigger& other1410) { + resourcePlanName = other1410.resourcePlanName; + triggerName = other1410.triggerName; + triggerExpression = other1410.triggerExpression; + actionExpression = other1410.actionExpression; + isInUnmanaged = other1410.isInUnmanaged; + ns = other1410.ns; + __isset = other1410.__isset; +} +WMTrigger& WMTrigger::operator=(const WMTrigger& other1411) { + resourcePlanName = other1411.resourcePlanName; + triggerName = other1411.triggerName; + triggerExpression = other1411.triggerExpression; + actionExpression = other1411.actionExpression; + isInUnmanaged = other1411.isInUnmanaged; + ns = other1411.ns; + __isset = other1411.__isset; + return *this; +} +void WMTrigger::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMTrigger("; + out << "resourcePlanName=" << to_string(resourcePlanName); + out << ", " << "triggerName=" << to_string(triggerName); + out << ", " << "triggerExpression="; (__isset.triggerExpression ? (out << to_string(triggerExpression)) : (out << "")); + out << ", " << "actionExpression="; (__isset.actionExpression ? (out << to_string(actionExpression)) : (out << "")); + out << ", " << "isInUnmanaged="; (__isset.isInUnmanaged ? (out << to_string(isInUnmanaged)) : (out << "")); + out << ", " << "ns="; (__isset.ns ? (out << to_string(ns)) : (out << "")); + out << ")"; +} + + +WMMapping::~WMMapping() noexcept { +} + +WMMapping::WMMapping() noexcept + : resourcePlanName(), + entityType(), + entityName(), + poolPath(), + ordering(0), + ns() { +} + +void WMMapping::__set_resourcePlanName(const std::string& val) { + this->resourcePlanName = val; +} + +void WMMapping::__set_entityType(const std::string& val) { + this->entityType = val; +} + +void WMMapping::__set_entityName(const std::string& val) { + this->entityName = val; +} + +void WMMapping::__set_poolPath(const std::string& val) { + this->poolPath = val; +__isset.poolPath = true; +} + +void WMMapping::__set_ordering(const int32_t val) { + this->ordering = val; +__isset.ordering = true; +} + +void WMMapping::__set_ns(const std::string& val) { + this->ns = val; +__isset.ns = true; +} +std::ostream& operator<<(std::ostream& out, const WMMapping& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMMapping::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_resourcePlanName = false; + bool isset_entityType = false; + bool isset_entityName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->resourcePlanName); + isset_resourcePlanName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->entityType); + isset_entityType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->entityName); + isset_entityName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->poolPath); + this->__isset.poolPath = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->ordering); + this->__isset.ordering = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ns); + this->__isset.ns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_resourcePlanName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_entityType) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_entityName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t WMMapping::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMMapping"); + + xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->resourcePlanName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("entityType", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->entityType); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("entityName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->entityName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.poolPath) { + xfer += oprot->writeFieldBegin("poolPath", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->poolPath); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ordering) { + xfer += oprot->writeFieldBegin("ordering", ::apache::thrift::protocol::T_I32, 5); + xfer += oprot->writeI32(this->ordering); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ns) { + xfer += oprot->writeFieldBegin("ns", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->ns); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMMapping &a, WMMapping &b) noexcept { + using ::std::swap; + swap(a.resourcePlanName, b.resourcePlanName); + swap(a.entityType, b.entityType); + swap(a.entityName, b.entityName); + swap(a.poolPath, b.poolPath); + swap(a.ordering, b.ordering); + swap(a.ns, b.ns); + swap(a.__isset, b.__isset); +} + +bool WMMapping::operator==(const WMMapping & rhs) const +{ + if (!(resourcePlanName == rhs.resourcePlanName)) + return false; + if (!(entityType == rhs.entityType)) + return false; + if (!(entityName == rhs.entityName)) + return false; + if (__isset.poolPath != rhs.__isset.poolPath) + return false; + else if (__isset.poolPath && !(poolPath == rhs.poolPath)) + return false; + if (__isset.ordering != rhs.__isset.ordering) + return false; + else if (__isset.ordering && !(ordering == rhs.ordering)) + return false; + if (__isset.ns != rhs.__isset.ns) + return false; + else if (__isset.ns && !(ns == rhs.ns)) + return false; + return true; +} + +WMMapping::WMMapping(const WMMapping& other1412) { + resourcePlanName = other1412.resourcePlanName; + entityType = other1412.entityType; + entityName = other1412.entityName; + poolPath = other1412.poolPath; + ordering = other1412.ordering; + ns = other1412.ns; + __isset = other1412.__isset; +} +WMMapping& WMMapping::operator=(const WMMapping& other1413) { + resourcePlanName = other1413.resourcePlanName; + entityType = other1413.entityType; + entityName = other1413.entityName; + poolPath = other1413.poolPath; + ordering = other1413.ordering; + ns = other1413.ns; + __isset = other1413.__isset; + return *this; +} +void WMMapping::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMMapping("; + out << "resourcePlanName=" << to_string(resourcePlanName); + out << ", " << "entityType=" << to_string(entityType); + out << ", " << "entityName=" << to_string(entityName); + out << ", " << "poolPath="; (__isset.poolPath ? (out << to_string(poolPath)) : (out << "")); + out << ", " << "ordering="; (__isset.ordering ? (out << to_string(ordering)) : (out << "")); + out << ", " << "ns="; (__isset.ns ? (out << to_string(ns)) : (out << "")); + out << ")"; +} + + +WMPoolTrigger::~WMPoolTrigger() noexcept { +} + +WMPoolTrigger::WMPoolTrigger() noexcept + : pool(), + trigger(), + ns() { +} + +void WMPoolTrigger::__set_pool(const std::string& val) { + this->pool = val; +} + +void WMPoolTrigger::__set_trigger(const std::string& val) { + this->trigger = val; +} + +void WMPoolTrigger::__set_ns(const std::string& val) { + this->ns = val; +__isset.ns = true; +} +std::ostream& operator<<(std::ostream& out, const WMPoolTrigger& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMPoolTrigger::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_pool = false; + bool isset_trigger = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->pool); + isset_pool = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->trigger); + isset_trigger = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ns); + this->__isset.ns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_pool) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_trigger) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t WMPoolTrigger::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMPoolTrigger"); + + xfer += oprot->writeFieldBegin("pool", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->pool); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("trigger", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->trigger); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.ns) { + xfer += oprot->writeFieldBegin("ns", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->ns); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMPoolTrigger &a, WMPoolTrigger &b) noexcept { + using ::std::swap; + swap(a.pool, b.pool); + swap(a.trigger, b.trigger); + swap(a.ns, b.ns); + swap(a.__isset, b.__isset); +} + +bool WMPoolTrigger::operator==(const WMPoolTrigger & rhs) const +{ + if (!(pool == rhs.pool)) + return false; + if (!(trigger == rhs.trigger)) + return false; + if (__isset.ns != rhs.__isset.ns) + return false; + else if (__isset.ns && !(ns == rhs.ns)) + return false; + return true; +} + +WMPoolTrigger::WMPoolTrigger(const WMPoolTrigger& other1414) { + pool = other1414.pool; + trigger = other1414.trigger; + ns = other1414.ns; + __isset = other1414.__isset; +} +WMPoolTrigger& WMPoolTrigger::operator=(const WMPoolTrigger& other1415) { + pool = other1415.pool; + trigger = other1415.trigger; + ns = other1415.ns; + __isset = other1415.__isset; + return *this; +} +void WMPoolTrigger::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMPoolTrigger("; + out << "pool=" << to_string(pool); + out << ", " << "trigger=" << to_string(trigger); + out << ", " << "ns="; (__isset.ns ? (out << to_string(ns)) : (out << "")); + out << ")"; +} + + +WMFullResourcePlan::~WMFullResourcePlan() noexcept { +} + +WMFullResourcePlan::WMFullResourcePlan() noexcept { +} + +void WMFullResourcePlan::__set_plan(const WMResourcePlan& val) { + this->plan = val; +} + +void WMFullResourcePlan::__set_pools(const std::vector & val) { + this->pools = val; +} + +void WMFullResourcePlan::__set_mappings(const std::vector & val) { + this->mappings = val; +__isset.mappings = true; +} + +void WMFullResourcePlan::__set_triggers(const std::vector & val) { + this->triggers = val; +__isset.triggers = true; +} + +void WMFullResourcePlan::__set_poolTriggers(const std::vector & val) { + this->poolTriggers = val; +__isset.poolTriggers = true; +} +std::ostream& operator<<(std::ostream& out, const WMFullResourcePlan& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMFullResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_plan = false; + bool isset_pools = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->plan.read(iprot); + isset_plan = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->pools.clear(); + uint32_t _size1416; + ::apache::thrift::protocol::TType _etype1419; + xfer += iprot->readListBegin(_etype1419, _size1416); + this->pools.resize(_size1416); + uint32_t _i1420; + for (_i1420 = 0; _i1420 < _size1416; ++_i1420) + { + xfer += this->pools[_i1420].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_pools = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->mappings.clear(); + uint32_t _size1421; + ::apache::thrift::protocol::TType _etype1424; + xfer += iprot->readListBegin(_etype1424, _size1421); + this->mappings.resize(_size1421); + uint32_t _i1425; + for (_i1425 = 0; _i1425 < _size1421; ++_i1425) + { + xfer += this->mappings[_i1425].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.mappings = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->triggers.clear(); + uint32_t _size1426; + ::apache::thrift::protocol::TType _etype1429; + xfer += iprot->readListBegin(_etype1429, _size1426); + this->triggers.resize(_size1426); + uint32_t _i1430; + for (_i1430 = 0; _i1430 < _size1426; ++_i1430) + { + xfer += this->triggers[_i1430].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.triggers = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->poolTriggers.clear(); + uint32_t _size1431; + ::apache::thrift::protocol::TType _etype1434; + xfer += iprot->readListBegin(_etype1434, _size1431); + this->poolTriggers.resize(_size1431); + uint32_t _i1435; + for (_i1435 = 0; _i1435 < _size1431; ++_i1435) + { + xfer += this->poolTriggers[_i1435].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.poolTriggers = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_plan) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_pools) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t WMFullResourcePlan::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMFullResourcePlan"); + + xfer += oprot->writeFieldBegin("plan", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->plan.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("pools", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->pools.size())); + std::vector ::const_iterator _iter1436; + for (_iter1436 = this->pools.begin(); _iter1436 != this->pools.end(); ++_iter1436) + { + xfer += (*_iter1436).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.mappings) { + xfer += oprot->writeFieldBegin("mappings", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->mappings.size())); + std::vector ::const_iterator _iter1437; + for (_iter1437 = this->mappings.begin(); _iter1437 != this->mappings.end(); ++_iter1437) + { + xfer += (*_iter1437).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.triggers) { + xfer += oprot->writeFieldBegin("triggers", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->triggers.size())); + std::vector ::const_iterator _iter1438; + for (_iter1438 = this->triggers.begin(); _iter1438 != this->triggers.end(); ++_iter1438) + { + xfer += (*_iter1438).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.poolTriggers) { + xfer += oprot->writeFieldBegin("poolTriggers", ::apache::thrift::protocol::T_LIST, 5); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->poolTriggers.size())); + std::vector ::const_iterator _iter1439; + for (_iter1439 = this->poolTriggers.begin(); _iter1439 != this->poolTriggers.end(); ++_iter1439) + { + xfer += (*_iter1439).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMFullResourcePlan &a, WMFullResourcePlan &b) noexcept { + using ::std::swap; + swap(a.plan, b.plan); + swap(a.pools, b.pools); + swap(a.mappings, b.mappings); + swap(a.triggers, b.triggers); + swap(a.poolTriggers, b.poolTriggers); + swap(a.__isset, b.__isset); +} + +bool WMFullResourcePlan::operator==(const WMFullResourcePlan & rhs) const +{ + if (!(plan == rhs.plan)) + return false; + if (!(pools == rhs.pools)) + return false; + if (__isset.mappings != rhs.__isset.mappings) + return false; + else if (__isset.mappings && !(mappings == rhs.mappings)) + return false; + if (__isset.triggers != rhs.__isset.triggers) + return false; + else if (__isset.triggers && !(triggers == rhs.triggers)) + return false; + if (__isset.poolTriggers != rhs.__isset.poolTriggers) + return false; + else if (__isset.poolTriggers && !(poolTriggers == rhs.poolTriggers)) + return false; + return true; +} + +WMFullResourcePlan::WMFullResourcePlan(const WMFullResourcePlan& other1440) { + plan = other1440.plan; + pools = other1440.pools; + mappings = other1440.mappings; + triggers = other1440.triggers; + poolTriggers = other1440.poolTriggers; + __isset = other1440.__isset; +} +WMFullResourcePlan& WMFullResourcePlan::operator=(const WMFullResourcePlan& other1441) { + plan = other1441.plan; + pools = other1441.pools; + mappings = other1441.mappings; + triggers = other1441.triggers; + poolTriggers = other1441.poolTriggers; + __isset = other1441.__isset; + return *this; +} +void WMFullResourcePlan::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMFullResourcePlan("; + out << "plan=" << to_string(plan); + out << ", " << "pools=" << to_string(pools); + out << ", " << "mappings="; (__isset.mappings ? (out << to_string(mappings)) : (out << "")); + out << ", " << "triggers="; (__isset.triggers ? (out << to_string(triggers)) : (out << "")); + out << ", " << "poolTriggers="; (__isset.poolTriggers ? (out << to_string(poolTriggers)) : (out << "")); + out << ")"; +} + + +WMCreateResourcePlanRequest::~WMCreateResourcePlanRequest() noexcept { +} + +WMCreateResourcePlanRequest::WMCreateResourcePlanRequest() noexcept + : copyFrom() { +} + +void WMCreateResourcePlanRequest::__set_resourcePlan(const WMResourcePlan& val) { + this->resourcePlan = val; +__isset.resourcePlan = true; +} + +void WMCreateResourcePlanRequest::__set_copyFrom(const std::string& val) { + this->copyFrom = val; +__isset.copyFrom = true; +} +std::ostream& operator<<(std::ostream& out, const WMCreateResourcePlanRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMCreateResourcePlanRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->resourcePlan.read(iprot); + this->__isset.resourcePlan = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->copyFrom); + this->__isset.copyFrom = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMCreateResourcePlanRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMCreateResourcePlanRequest"); + + if (this->__isset.resourcePlan) { + xfer += oprot->writeFieldBegin("resourcePlan", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->resourcePlan.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.copyFrom) { + xfer += oprot->writeFieldBegin("copyFrom", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->copyFrom); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMCreateResourcePlanRequest &a, WMCreateResourcePlanRequest &b) noexcept { + using ::std::swap; + swap(a.resourcePlan, b.resourcePlan); + swap(a.copyFrom, b.copyFrom); + swap(a.__isset, b.__isset); +} + +bool WMCreateResourcePlanRequest::operator==(const WMCreateResourcePlanRequest & rhs) const +{ + if (__isset.resourcePlan != rhs.__isset.resourcePlan) + return false; + else if (__isset.resourcePlan && !(resourcePlan == rhs.resourcePlan)) + return false; + if (__isset.copyFrom != rhs.__isset.copyFrom) + return false; + else if (__isset.copyFrom && !(copyFrom == rhs.copyFrom)) + return false; + return true; +} + +WMCreateResourcePlanRequest::WMCreateResourcePlanRequest(const WMCreateResourcePlanRequest& other1442) { + resourcePlan = other1442.resourcePlan; + copyFrom = other1442.copyFrom; + __isset = other1442.__isset; +} +WMCreateResourcePlanRequest& WMCreateResourcePlanRequest::operator=(const WMCreateResourcePlanRequest& other1443) { + resourcePlan = other1443.resourcePlan; + copyFrom = other1443.copyFrom; + __isset = other1443.__isset; + return *this; +} +void WMCreateResourcePlanRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMCreateResourcePlanRequest("; + out << "resourcePlan="; (__isset.resourcePlan ? (out << to_string(resourcePlan)) : (out << "")); + out << ", " << "copyFrom="; (__isset.copyFrom ? (out << to_string(copyFrom)) : (out << "")); + out << ")"; +} + + +WMCreateResourcePlanResponse::~WMCreateResourcePlanResponse() noexcept { +} + +WMCreateResourcePlanResponse::WMCreateResourcePlanResponse() noexcept { +} +std::ostream& operator<<(std::ostream& out, const WMCreateResourcePlanResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMCreateResourcePlanResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMCreateResourcePlanResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMCreateResourcePlanResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMCreateResourcePlanResponse &a, WMCreateResourcePlanResponse &b) noexcept { + using ::std::swap; + (void) a; + (void) b; +} + +bool WMCreateResourcePlanResponse::operator==(const WMCreateResourcePlanResponse & /* rhs */) const +{ + return true; +} + +WMCreateResourcePlanResponse::WMCreateResourcePlanResponse(const WMCreateResourcePlanResponse& other1444) noexcept { + (void) other1444; +} +WMCreateResourcePlanResponse& WMCreateResourcePlanResponse::operator=(const WMCreateResourcePlanResponse& other1445) noexcept { + (void) other1445; + return *this; +} +void WMCreateResourcePlanResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMCreateResourcePlanResponse("; + out << ")"; +} + + +WMGetActiveResourcePlanRequest::~WMGetActiveResourcePlanRequest() noexcept { +} + +WMGetActiveResourcePlanRequest::WMGetActiveResourcePlanRequest() noexcept + : ns() { +} + +void WMGetActiveResourcePlanRequest::__set_ns(const std::string& val) { + this->ns = val; +__isset.ns = true; +} +std::ostream& operator<<(std::ostream& out, const WMGetActiveResourcePlanRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMGetActiveResourcePlanRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ns); + this->__isset.ns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMGetActiveResourcePlanRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMGetActiveResourcePlanRequest"); + + if (this->__isset.ns) { + xfer += oprot->writeFieldBegin("ns", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->ns); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMGetActiveResourcePlanRequest &a, WMGetActiveResourcePlanRequest &b) noexcept { + using ::std::swap; + swap(a.ns, b.ns); + swap(a.__isset, b.__isset); +} + +bool WMGetActiveResourcePlanRequest::operator==(const WMGetActiveResourcePlanRequest & rhs) const +{ + if (__isset.ns != rhs.__isset.ns) + return false; + else if (__isset.ns && !(ns == rhs.ns)) + return false; + return true; +} + +WMGetActiveResourcePlanRequest::WMGetActiveResourcePlanRequest(const WMGetActiveResourcePlanRequest& other1446) { + ns = other1446.ns; + __isset = other1446.__isset; +} +WMGetActiveResourcePlanRequest& WMGetActiveResourcePlanRequest::operator=(const WMGetActiveResourcePlanRequest& other1447) { + ns = other1447.ns; + __isset = other1447.__isset; + return *this; +} +void WMGetActiveResourcePlanRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMGetActiveResourcePlanRequest("; + out << "ns="; (__isset.ns ? (out << to_string(ns)) : (out << "")); + out << ")"; +} + + +WMGetActiveResourcePlanResponse::~WMGetActiveResourcePlanResponse() noexcept { +} + +WMGetActiveResourcePlanResponse::WMGetActiveResourcePlanResponse() noexcept { +} + +void WMGetActiveResourcePlanResponse::__set_resourcePlan(const WMFullResourcePlan& val) { + this->resourcePlan = val; +__isset.resourcePlan = true; +} +std::ostream& operator<<(std::ostream& out, const WMGetActiveResourcePlanResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMGetActiveResourcePlanResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->resourcePlan.read(iprot); + this->__isset.resourcePlan = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMGetActiveResourcePlanResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMGetActiveResourcePlanResponse"); + + if (this->__isset.resourcePlan) { + xfer += oprot->writeFieldBegin("resourcePlan", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->resourcePlan.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMGetActiveResourcePlanResponse &a, WMGetActiveResourcePlanResponse &b) noexcept { + using ::std::swap; + swap(a.resourcePlan, b.resourcePlan); + swap(a.__isset, b.__isset); +} + +bool WMGetActiveResourcePlanResponse::operator==(const WMGetActiveResourcePlanResponse & rhs) const +{ + if (__isset.resourcePlan != rhs.__isset.resourcePlan) + return false; + else if (__isset.resourcePlan && !(resourcePlan == rhs.resourcePlan)) + return false; + return true; +} + +WMGetActiveResourcePlanResponse::WMGetActiveResourcePlanResponse(const WMGetActiveResourcePlanResponse& other1448) { + resourcePlan = other1448.resourcePlan; + __isset = other1448.__isset; +} +WMGetActiveResourcePlanResponse& WMGetActiveResourcePlanResponse::operator=(const WMGetActiveResourcePlanResponse& other1449) { + resourcePlan = other1449.resourcePlan; + __isset = other1449.__isset; + return *this; +} +void WMGetActiveResourcePlanResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMGetActiveResourcePlanResponse("; + out << "resourcePlan="; (__isset.resourcePlan ? (out << to_string(resourcePlan)) : (out << "")); + out << ")"; +} + + +WMGetResourcePlanRequest::~WMGetResourcePlanRequest() noexcept { +} + +WMGetResourcePlanRequest::WMGetResourcePlanRequest() noexcept + : resourcePlanName(), + ns() { +} + +void WMGetResourcePlanRequest::__set_resourcePlanName(const std::string& val) { + this->resourcePlanName = val; +__isset.resourcePlanName = true; +} + +void WMGetResourcePlanRequest::__set_ns(const std::string& val) { + this->ns = val; +__isset.ns = true; +} +std::ostream& operator<<(std::ostream& out, const WMGetResourcePlanRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMGetResourcePlanRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->resourcePlanName); + this->__isset.resourcePlanName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ns); + this->__isset.ns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMGetResourcePlanRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMGetResourcePlanRequest"); + + if (this->__isset.resourcePlanName) { + xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->resourcePlanName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ns) { + xfer += oprot->writeFieldBegin("ns", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->ns); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMGetResourcePlanRequest &a, WMGetResourcePlanRequest &b) noexcept { + using ::std::swap; + swap(a.resourcePlanName, b.resourcePlanName); + swap(a.ns, b.ns); + swap(a.__isset, b.__isset); +} + +bool WMGetResourcePlanRequest::operator==(const WMGetResourcePlanRequest & rhs) const +{ + if (__isset.resourcePlanName != rhs.__isset.resourcePlanName) + return false; + else if (__isset.resourcePlanName && !(resourcePlanName == rhs.resourcePlanName)) + return false; + if (__isset.ns != rhs.__isset.ns) + return false; + else if (__isset.ns && !(ns == rhs.ns)) + return false; + return true; +} + +WMGetResourcePlanRequest::WMGetResourcePlanRequest(const WMGetResourcePlanRequest& other1450) { + resourcePlanName = other1450.resourcePlanName; + ns = other1450.ns; + __isset = other1450.__isset; +} +WMGetResourcePlanRequest& WMGetResourcePlanRequest::operator=(const WMGetResourcePlanRequest& other1451) { + resourcePlanName = other1451.resourcePlanName; + ns = other1451.ns; + __isset = other1451.__isset; + return *this; +} +void WMGetResourcePlanRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMGetResourcePlanRequest("; + out << "resourcePlanName="; (__isset.resourcePlanName ? (out << to_string(resourcePlanName)) : (out << "")); + out << ", " << "ns="; (__isset.ns ? (out << to_string(ns)) : (out << "")); + out << ")"; +} + + +WMGetResourcePlanResponse::~WMGetResourcePlanResponse() noexcept { +} + +WMGetResourcePlanResponse::WMGetResourcePlanResponse() noexcept { +} + +void WMGetResourcePlanResponse::__set_resourcePlan(const WMFullResourcePlan& val) { + this->resourcePlan = val; +__isset.resourcePlan = true; +} +std::ostream& operator<<(std::ostream& out, const WMGetResourcePlanResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMGetResourcePlanResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->resourcePlan.read(iprot); + this->__isset.resourcePlan = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMGetResourcePlanResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMGetResourcePlanResponse"); + + if (this->__isset.resourcePlan) { + xfer += oprot->writeFieldBegin("resourcePlan", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->resourcePlan.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMGetResourcePlanResponse &a, WMGetResourcePlanResponse &b) noexcept { + using ::std::swap; + swap(a.resourcePlan, b.resourcePlan); + swap(a.__isset, b.__isset); +} + +bool WMGetResourcePlanResponse::operator==(const WMGetResourcePlanResponse & rhs) const +{ + if (__isset.resourcePlan != rhs.__isset.resourcePlan) + return false; + else if (__isset.resourcePlan && !(resourcePlan == rhs.resourcePlan)) + return false; + return true; +} + +WMGetResourcePlanResponse::WMGetResourcePlanResponse(const WMGetResourcePlanResponse& other1452) { + resourcePlan = other1452.resourcePlan; + __isset = other1452.__isset; +} +WMGetResourcePlanResponse& WMGetResourcePlanResponse::operator=(const WMGetResourcePlanResponse& other1453) { + resourcePlan = other1453.resourcePlan; + __isset = other1453.__isset; + return *this; +} +void WMGetResourcePlanResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMGetResourcePlanResponse("; + out << "resourcePlan="; (__isset.resourcePlan ? (out << to_string(resourcePlan)) : (out << "")); + out << ")"; +} + + +WMGetAllResourcePlanRequest::~WMGetAllResourcePlanRequest() noexcept { +} + +WMGetAllResourcePlanRequest::WMGetAllResourcePlanRequest() noexcept + : ns() { +} + +void WMGetAllResourcePlanRequest::__set_ns(const std::string& val) { + this->ns = val; +__isset.ns = true; +} +std::ostream& operator<<(std::ostream& out, const WMGetAllResourcePlanRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMGetAllResourcePlanRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ns); + this->__isset.ns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMGetAllResourcePlanRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMGetAllResourcePlanRequest"); + + if (this->__isset.ns) { + xfer += oprot->writeFieldBegin("ns", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->ns); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMGetAllResourcePlanRequest &a, WMGetAllResourcePlanRequest &b) noexcept { + using ::std::swap; + swap(a.ns, b.ns); + swap(a.__isset, b.__isset); +} + +bool WMGetAllResourcePlanRequest::operator==(const WMGetAllResourcePlanRequest & rhs) const +{ + if (__isset.ns != rhs.__isset.ns) + return false; + else if (__isset.ns && !(ns == rhs.ns)) + return false; + return true; +} + +WMGetAllResourcePlanRequest::WMGetAllResourcePlanRequest(const WMGetAllResourcePlanRequest& other1454) { + ns = other1454.ns; + __isset = other1454.__isset; +} +WMGetAllResourcePlanRequest& WMGetAllResourcePlanRequest::operator=(const WMGetAllResourcePlanRequest& other1455) { + ns = other1455.ns; + __isset = other1455.__isset; + return *this; +} +void WMGetAllResourcePlanRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMGetAllResourcePlanRequest("; + out << "ns="; (__isset.ns ? (out << to_string(ns)) : (out << "")); + out << ")"; +} + + +WMGetAllResourcePlanResponse::~WMGetAllResourcePlanResponse() noexcept { +} + +WMGetAllResourcePlanResponse::WMGetAllResourcePlanResponse() noexcept { +} + +void WMGetAllResourcePlanResponse::__set_resourcePlans(const std::vector & val) { + this->resourcePlans = val; +__isset.resourcePlans = true; +} +std::ostream& operator<<(std::ostream& out, const WMGetAllResourcePlanResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMGetAllResourcePlanResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->resourcePlans.clear(); + uint32_t _size1456; + ::apache::thrift::protocol::TType _etype1459; + xfer += iprot->readListBegin(_etype1459, _size1456); + this->resourcePlans.resize(_size1456); + uint32_t _i1460; + for (_i1460 = 0; _i1460 < _size1456; ++_i1460) + { + xfer += this->resourcePlans[_i1460].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.resourcePlans = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMGetAllResourcePlanResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMGetAllResourcePlanResponse"); + + if (this->__isset.resourcePlans) { + xfer += oprot->writeFieldBegin("resourcePlans", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->resourcePlans.size())); + std::vector ::const_iterator _iter1461; + for (_iter1461 = this->resourcePlans.begin(); _iter1461 != this->resourcePlans.end(); ++_iter1461) + { + xfer += (*_iter1461).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMGetAllResourcePlanResponse &a, WMGetAllResourcePlanResponse &b) noexcept { + using ::std::swap; + swap(a.resourcePlans, b.resourcePlans); + swap(a.__isset, b.__isset); +} + +bool WMGetAllResourcePlanResponse::operator==(const WMGetAllResourcePlanResponse & rhs) const +{ + if (__isset.resourcePlans != rhs.__isset.resourcePlans) + return false; + else if (__isset.resourcePlans && !(resourcePlans == rhs.resourcePlans)) + return false; + return true; +} + +WMGetAllResourcePlanResponse::WMGetAllResourcePlanResponse(const WMGetAllResourcePlanResponse& other1462) { + resourcePlans = other1462.resourcePlans; + __isset = other1462.__isset; +} +WMGetAllResourcePlanResponse& WMGetAllResourcePlanResponse::operator=(const WMGetAllResourcePlanResponse& other1463) { + resourcePlans = other1463.resourcePlans; + __isset = other1463.__isset; + return *this; +} +void WMGetAllResourcePlanResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMGetAllResourcePlanResponse("; + out << "resourcePlans="; (__isset.resourcePlans ? (out << to_string(resourcePlans)) : (out << "")); + out << ")"; +} + + +WMAlterResourcePlanRequest::~WMAlterResourcePlanRequest() noexcept { +} + +WMAlterResourcePlanRequest::WMAlterResourcePlanRequest() noexcept + : resourcePlanName(), + isEnableAndActivate(0), + isForceDeactivate(0), + isReplace(0), + ns() { +} + +void WMAlterResourcePlanRequest::__set_resourcePlanName(const std::string& val) { + this->resourcePlanName = val; +__isset.resourcePlanName = true; +} + +void WMAlterResourcePlanRequest::__set_resourcePlan(const WMNullableResourcePlan& val) { + this->resourcePlan = val; +__isset.resourcePlan = true; +} + +void WMAlterResourcePlanRequest::__set_isEnableAndActivate(const bool val) { + this->isEnableAndActivate = val; +__isset.isEnableAndActivate = true; +} + +void WMAlterResourcePlanRequest::__set_isForceDeactivate(const bool val) { + this->isForceDeactivate = val; +__isset.isForceDeactivate = true; +} + +void WMAlterResourcePlanRequest::__set_isReplace(const bool val) { + this->isReplace = val; +__isset.isReplace = true; +} + +void WMAlterResourcePlanRequest::__set_ns(const std::string& val) { + this->ns = val; +__isset.ns = true; +} +std::ostream& operator<<(std::ostream& out, const WMAlterResourcePlanRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMAlterResourcePlanRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->resourcePlanName); + this->__isset.resourcePlanName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->resourcePlan.read(iprot); + this->__isset.resourcePlan = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isEnableAndActivate); + this->__isset.isEnableAndActivate = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isForceDeactivate); + this->__isset.isForceDeactivate = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isReplace); + this->__isset.isReplace = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ns); + this->__isset.ns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMAlterResourcePlanRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMAlterResourcePlanRequest"); + + if (this->__isset.resourcePlanName) { + xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->resourcePlanName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.resourcePlan) { + xfer += oprot->writeFieldBegin("resourcePlan", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->resourcePlan.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.isEnableAndActivate) { + xfer += oprot->writeFieldBegin("isEnableAndActivate", ::apache::thrift::protocol::T_BOOL, 3); + xfer += oprot->writeBool(this->isEnableAndActivate); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.isForceDeactivate) { + xfer += oprot->writeFieldBegin("isForceDeactivate", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool(this->isForceDeactivate); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.isReplace) { + xfer += oprot->writeFieldBegin("isReplace", ::apache::thrift::protocol::T_BOOL, 5); + xfer += oprot->writeBool(this->isReplace); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ns) { + xfer += oprot->writeFieldBegin("ns", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->ns); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMAlterResourcePlanRequest &a, WMAlterResourcePlanRequest &b) noexcept { + using ::std::swap; + swap(a.resourcePlanName, b.resourcePlanName); + swap(a.resourcePlan, b.resourcePlan); + swap(a.isEnableAndActivate, b.isEnableAndActivate); + swap(a.isForceDeactivate, b.isForceDeactivate); + swap(a.isReplace, b.isReplace); + swap(a.ns, b.ns); + swap(a.__isset, b.__isset); +} + +bool WMAlterResourcePlanRequest::operator==(const WMAlterResourcePlanRequest & rhs) const +{ + if (__isset.resourcePlanName != rhs.__isset.resourcePlanName) + return false; + else if (__isset.resourcePlanName && !(resourcePlanName == rhs.resourcePlanName)) + return false; + if (__isset.resourcePlan != rhs.__isset.resourcePlan) + return false; + else if (__isset.resourcePlan && !(resourcePlan == rhs.resourcePlan)) + return false; + if (__isset.isEnableAndActivate != rhs.__isset.isEnableAndActivate) + return false; + else if (__isset.isEnableAndActivate && !(isEnableAndActivate == rhs.isEnableAndActivate)) + return false; + if (__isset.isForceDeactivate != rhs.__isset.isForceDeactivate) + return false; + else if (__isset.isForceDeactivate && !(isForceDeactivate == rhs.isForceDeactivate)) + return false; + if (__isset.isReplace != rhs.__isset.isReplace) + return false; + else if (__isset.isReplace && !(isReplace == rhs.isReplace)) + return false; + if (__isset.ns != rhs.__isset.ns) + return false; + else if (__isset.ns && !(ns == rhs.ns)) + return false; + return true; +} + +WMAlterResourcePlanRequest::WMAlterResourcePlanRequest(const WMAlterResourcePlanRequest& other1464) { + resourcePlanName = other1464.resourcePlanName; + resourcePlan = other1464.resourcePlan; + isEnableAndActivate = other1464.isEnableAndActivate; + isForceDeactivate = other1464.isForceDeactivate; + isReplace = other1464.isReplace; + ns = other1464.ns; + __isset = other1464.__isset; +} +WMAlterResourcePlanRequest& WMAlterResourcePlanRequest::operator=(const WMAlterResourcePlanRequest& other1465) { + resourcePlanName = other1465.resourcePlanName; + resourcePlan = other1465.resourcePlan; + isEnableAndActivate = other1465.isEnableAndActivate; + isForceDeactivate = other1465.isForceDeactivate; + isReplace = other1465.isReplace; + ns = other1465.ns; + __isset = other1465.__isset; + return *this; +} +void WMAlterResourcePlanRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMAlterResourcePlanRequest("; + out << "resourcePlanName="; (__isset.resourcePlanName ? (out << to_string(resourcePlanName)) : (out << "")); + out << ", " << "resourcePlan="; (__isset.resourcePlan ? (out << to_string(resourcePlan)) : (out << "")); + out << ", " << "isEnableAndActivate="; (__isset.isEnableAndActivate ? (out << to_string(isEnableAndActivate)) : (out << "")); + out << ", " << "isForceDeactivate="; (__isset.isForceDeactivate ? (out << to_string(isForceDeactivate)) : (out << "")); + out << ", " << "isReplace="; (__isset.isReplace ? (out << to_string(isReplace)) : (out << "")); + out << ", " << "ns="; (__isset.ns ? (out << to_string(ns)) : (out << "")); + out << ")"; +} + + +WMAlterResourcePlanResponse::~WMAlterResourcePlanResponse() noexcept { +} + +WMAlterResourcePlanResponse::WMAlterResourcePlanResponse() noexcept { +} + +void WMAlterResourcePlanResponse::__set_fullResourcePlan(const WMFullResourcePlan& val) { + this->fullResourcePlan = val; +__isset.fullResourcePlan = true; +} +std::ostream& operator<<(std::ostream& out, const WMAlterResourcePlanResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMAlterResourcePlanResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->fullResourcePlan.read(iprot); + this->__isset.fullResourcePlan = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMAlterResourcePlanResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMAlterResourcePlanResponse"); + + if (this->__isset.fullResourcePlan) { + xfer += oprot->writeFieldBegin("fullResourcePlan", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->fullResourcePlan.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMAlterResourcePlanResponse &a, WMAlterResourcePlanResponse &b) noexcept { + using ::std::swap; + swap(a.fullResourcePlan, b.fullResourcePlan); + swap(a.__isset, b.__isset); +} + +bool WMAlterResourcePlanResponse::operator==(const WMAlterResourcePlanResponse & rhs) const +{ + if (__isset.fullResourcePlan != rhs.__isset.fullResourcePlan) + return false; + else if (__isset.fullResourcePlan && !(fullResourcePlan == rhs.fullResourcePlan)) + return false; + return true; +} + +WMAlterResourcePlanResponse::WMAlterResourcePlanResponse(const WMAlterResourcePlanResponse& other1466) { + fullResourcePlan = other1466.fullResourcePlan; + __isset = other1466.__isset; +} +WMAlterResourcePlanResponse& WMAlterResourcePlanResponse::operator=(const WMAlterResourcePlanResponse& other1467) { + fullResourcePlan = other1467.fullResourcePlan; + __isset = other1467.__isset; + return *this; +} +void WMAlterResourcePlanResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMAlterResourcePlanResponse("; + out << "fullResourcePlan="; (__isset.fullResourcePlan ? (out << to_string(fullResourcePlan)) : (out << "")); + out << ")"; +} + + +WMValidateResourcePlanRequest::~WMValidateResourcePlanRequest() noexcept { +} + +WMValidateResourcePlanRequest::WMValidateResourcePlanRequest() noexcept + : resourcePlanName(), + ns() { +} + +void WMValidateResourcePlanRequest::__set_resourcePlanName(const std::string& val) { + this->resourcePlanName = val; +__isset.resourcePlanName = true; +} + +void WMValidateResourcePlanRequest::__set_ns(const std::string& val) { + this->ns = val; +__isset.ns = true; +} +std::ostream& operator<<(std::ostream& out, const WMValidateResourcePlanRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMValidateResourcePlanRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->resourcePlanName); + this->__isset.resourcePlanName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ns); + this->__isset.ns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMValidateResourcePlanRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMValidateResourcePlanRequest"); + + if (this->__isset.resourcePlanName) { + xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->resourcePlanName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ns) { + xfer += oprot->writeFieldBegin("ns", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->ns); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMValidateResourcePlanRequest &a, WMValidateResourcePlanRequest &b) noexcept { + using ::std::swap; + swap(a.resourcePlanName, b.resourcePlanName); + swap(a.ns, b.ns); + swap(a.__isset, b.__isset); +} + +bool WMValidateResourcePlanRequest::operator==(const WMValidateResourcePlanRequest & rhs) const +{ + if (__isset.resourcePlanName != rhs.__isset.resourcePlanName) + return false; + else if (__isset.resourcePlanName && !(resourcePlanName == rhs.resourcePlanName)) + return false; + if (__isset.ns != rhs.__isset.ns) + return false; + else if (__isset.ns && !(ns == rhs.ns)) + return false; + return true; +} + +WMValidateResourcePlanRequest::WMValidateResourcePlanRequest(const WMValidateResourcePlanRequest& other1468) { + resourcePlanName = other1468.resourcePlanName; + ns = other1468.ns; + __isset = other1468.__isset; +} +WMValidateResourcePlanRequest& WMValidateResourcePlanRequest::operator=(const WMValidateResourcePlanRequest& other1469) { + resourcePlanName = other1469.resourcePlanName; + ns = other1469.ns; + __isset = other1469.__isset; + return *this; +} +void WMValidateResourcePlanRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMValidateResourcePlanRequest("; + out << "resourcePlanName="; (__isset.resourcePlanName ? (out << to_string(resourcePlanName)) : (out << "")); + out << ", " << "ns="; (__isset.ns ? (out << to_string(ns)) : (out << "")); + out << ")"; +} + + +WMValidateResourcePlanResponse::~WMValidateResourcePlanResponse() noexcept { +} + +WMValidateResourcePlanResponse::WMValidateResourcePlanResponse() noexcept { +} + +void WMValidateResourcePlanResponse::__set_errors(const std::vector & val) { + this->errors = val; +__isset.errors = true; +} + +void WMValidateResourcePlanResponse::__set_warnings(const std::vector & val) { + this->warnings = val; +__isset.warnings = true; +} +std::ostream& operator<<(std::ostream& out, const WMValidateResourcePlanResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMValidateResourcePlanResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->errors.clear(); + uint32_t _size1470; + ::apache::thrift::protocol::TType _etype1473; + xfer += iprot->readListBegin(_etype1473, _size1470); + this->errors.resize(_size1470); + uint32_t _i1474; + for (_i1474 = 0; _i1474 < _size1470; ++_i1474) + { + xfer += iprot->readString(this->errors[_i1474]); + } + xfer += iprot->readListEnd(); + } + this->__isset.errors = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->warnings.clear(); + uint32_t _size1475; + ::apache::thrift::protocol::TType _etype1478; + xfer += iprot->readListBegin(_etype1478, _size1475); + this->warnings.resize(_size1475); + uint32_t _i1479; + for (_i1479 = 0; _i1479 < _size1475; ++_i1479) + { + xfer += iprot->readString(this->warnings[_i1479]); + } + xfer += iprot->readListEnd(); + } + this->__isset.warnings = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMValidateResourcePlanResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMValidateResourcePlanResponse"); + + if (this->__isset.errors) { + xfer += oprot->writeFieldBegin("errors", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->errors.size())); + std::vector ::const_iterator _iter1480; + for (_iter1480 = this->errors.begin(); _iter1480 != this->errors.end(); ++_iter1480) + { + xfer += oprot->writeString((*_iter1480)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.warnings) { + xfer += oprot->writeFieldBegin("warnings", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->warnings.size())); + std::vector ::const_iterator _iter1481; + for (_iter1481 = this->warnings.begin(); _iter1481 != this->warnings.end(); ++_iter1481) + { + xfer += oprot->writeString((*_iter1481)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMValidateResourcePlanResponse &a, WMValidateResourcePlanResponse &b) noexcept { + using ::std::swap; + swap(a.errors, b.errors); + swap(a.warnings, b.warnings); + swap(a.__isset, b.__isset); +} + +bool WMValidateResourcePlanResponse::operator==(const WMValidateResourcePlanResponse & rhs) const +{ + if (__isset.errors != rhs.__isset.errors) + return false; + else if (__isset.errors && !(errors == rhs.errors)) + return false; + if (__isset.warnings != rhs.__isset.warnings) + return false; + else if (__isset.warnings && !(warnings == rhs.warnings)) + return false; + return true; +} + +WMValidateResourcePlanResponse::WMValidateResourcePlanResponse(const WMValidateResourcePlanResponse& other1482) { + errors = other1482.errors; + warnings = other1482.warnings; + __isset = other1482.__isset; +} +WMValidateResourcePlanResponse& WMValidateResourcePlanResponse::operator=(const WMValidateResourcePlanResponse& other1483) { + errors = other1483.errors; + warnings = other1483.warnings; + __isset = other1483.__isset; + return *this; +} +void WMValidateResourcePlanResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMValidateResourcePlanResponse("; + out << "errors="; (__isset.errors ? (out << to_string(errors)) : (out << "")); + out << ", " << "warnings="; (__isset.warnings ? (out << to_string(warnings)) : (out << "")); + out << ")"; +} + + +WMDropResourcePlanRequest::~WMDropResourcePlanRequest() noexcept { +} + +WMDropResourcePlanRequest::WMDropResourcePlanRequest() noexcept + : resourcePlanName(), + ns() { +} + +void WMDropResourcePlanRequest::__set_resourcePlanName(const std::string& val) { + this->resourcePlanName = val; +__isset.resourcePlanName = true; +} + +void WMDropResourcePlanRequest::__set_ns(const std::string& val) { + this->ns = val; +__isset.ns = true; +} +std::ostream& operator<<(std::ostream& out, const WMDropResourcePlanRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMDropResourcePlanRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->resourcePlanName); + this->__isset.resourcePlanName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ns); + this->__isset.ns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMDropResourcePlanRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMDropResourcePlanRequest"); + + if (this->__isset.resourcePlanName) { + xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->resourcePlanName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ns) { + xfer += oprot->writeFieldBegin("ns", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->ns); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMDropResourcePlanRequest &a, WMDropResourcePlanRequest &b) noexcept { + using ::std::swap; + swap(a.resourcePlanName, b.resourcePlanName); + swap(a.ns, b.ns); + swap(a.__isset, b.__isset); +} + +bool WMDropResourcePlanRequest::operator==(const WMDropResourcePlanRequest & rhs) const +{ + if (__isset.resourcePlanName != rhs.__isset.resourcePlanName) + return false; + else if (__isset.resourcePlanName && !(resourcePlanName == rhs.resourcePlanName)) + return false; + if (__isset.ns != rhs.__isset.ns) + return false; + else if (__isset.ns && !(ns == rhs.ns)) + return false; + return true; +} + +WMDropResourcePlanRequest::WMDropResourcePlanRequest(const WMDropResourcePlanRequest& other1484) { + resourcePlanName = other1484.resourcePlanName; + ns = other1484.ns; + __isset = other1484.__isset; +} +WMDropResourcePlanRequest& WMDropResourcePlanRequest::operator=(const WMDropResourcePlanRequest& other1485) { + resourcePlanName = other1485.resourcePlanName; + ns = other1485.ns; + __isset = other1485.__isset; + return *this; +} +void WMDropResourcePlanRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMDropResourcePlanRequest("; + out << "resourcePlanName="; (__isset.resourcePlanName ? (out << to_string(resourcePlanName)) : (out << "")); + out << ", " << "ns="; (__isset.ns ? (out << to_string(ns)) : (out << "")); + out << ")"; +} + + +WMDropResourcePlanResponse::~WMDropResourcePlanResponse() noexcept { +} + +WMDropResourcePlanResponse::WMDropResourcePlanResponse() noexcept { +} +std::ostream& operator<<(std::ostream& out, const WMDropResourcePlanResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMDropResourcePlanResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMDropResourcePlanResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMDropResourcePlanResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMDropResourcePlanResponse &a, WMDropResourcePlanResponse &b) noexcept { + using ::std::swap; + (void) a; + (void) b; +} + +bool WMDropResourcePlanResponse::operator==(const WMDropResourcePlanResponse & /* rhs */) const +{ + return true; +} + +WMDropResourcePlanResponse::WMDropResourcePlanResponse(const WMDropResourcePlanResponse& other1486) noexcept { + (void) other1486; +} +WMDropResourcePlanResponse& WMDropResourcePlanResponse::operator=(const WMDropResourcePlanResponse& other1487) noexcept { + (void) other1487; + return *this; +} +void WMDropResourcePlanResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMDropResourcePlanResponse("; + out << ")"; +} + + +WMCreateTriggerRequest::~WMCreateTriggerRequest() noexcept { +} + +WMCreateTriggerRequest::WMCreateTriggerRequest() noexcept { +} + +void WMCreateTriggerRequest::__set_trigger(const WMTrigger& val) { + this->trigger = val; +__isset.trigger = true; +} +std::ostream& operator<<(std::ostream& out, const WMCreateTriggerRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMCreateTriggerRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->trigger.read(iprot); + this->__isset.trigger = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMCreateTriggerRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMCreateTriggerRequest"); + + if (this->__isset.trigger) { + xfer += oprot->writeFieldBegin("trigger", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->trigger.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMCreateTriggerRequest &a, WMCreateTriggerRequest &b) noexcept { + using ::std::swap; + swap(a.trigger, b.trigger); + swap(a.__isset, b.__isset); +} + +bool WMCreateTriggerRequest::operator==(const WMCreateTriggerRequest & rhs) const +{ + if (__isset.trigger != rhs.__isset.trigger) + return false; + else if (__isset.trigger && !(trigger == rhs.trigger)) + return false; + return true; +} + +WMCreateTriggerRequest::WMCreateTriggerRequest(const WMCreateTriggerRequest& other1488) { + trigger = other1488.trigger; + __isset = other1488.__isset; +} +WMCreateTriggerRequest& WMCreateTriggerRequest::operator=(const WMCreateTriggerRequest& other1489) { + trigger = other1489.trigger; + __isset = other1489.__isset; + return *this; +} +void WMCreateTriggerRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMCreateTriggerRequest("; + out << "trigger="; (__isset.trigger ? (out << to_string(trigger)) : (out << "")); + out << ")"; +} + + +WMCreateTriggerResponse::~WMCreateTriggerResponse() noexcept { +} + +WMCreateTriggerResponse::WMCreateTriggerResponse() noexcept { +} +std::ostream& operator<<(std::ostream& out, const WMCreateTriggerResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMCreateTriggerResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMCreateTriggerResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMCreateTriggerResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMCreateTriggerResponse &a, WMCreateTriggerResponse &b) noexcept { + using ::std::swap; + (void) a; + (void) b; +} + +bool WMCreateTriggerResponse::operator==(const WMCreateTriggerResponse & /* rhs */) const +{ + return true; +} + +WMCreateTriggerResponse::WMCreateTriggerResponse(const WMCreateTriggerResponse& other1490) noexcept { + (void) other1490; +} +WMCreateTriggerResponse& WMCreateTriggerResponse::operator=(const WMCreateTriggerResponse& other1491) noexcept { + (void) other1491; + return *this; +} +void WMCreateTriggerResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMCreateTriggerResponse("; + out << ")"; +} + + +WMAlterTriggerRequest::~WMAlterTriggerRequest() noexcept { +} + +WMAlterTriggerRequest::WMAlterTriggerRequest() noexcept { +} + +void WMAlterTriggerRequest::__set_trigger(const WMTrigger& val) { + this->trigger = val; +__isset.trigger = true; +} +std::ostream& operator<<(std::ostream& out, const WMAlterTriggerRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMAlterTriggerRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->trigger.read(iprot); + this->__isset.trigger = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMAlterTriggerRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMAlterTriggerRequest"); + + if (this->__isset.trigger) { + xfer += oprot->writeFieldBegin("trigger", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->trigger.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMAlterTriggerRequest &a, WMAlterTriggerRequest &b) noexcept { + using ::std::swap; + swap(a.trigger, b.trigger); + swap(a.__isset, b.__isset); +} + +bool WMAlterTriggerRequest::operator==(const WMAlterTriggerRequest & rhs) const +{ + if (__isset.trigger != rhs.__isset.trigger) + return false; + else if (__isset.trigger && !(trigger == rhs.trigger)) + return false; + return true; +} + +WMAlterTriggerRequest::WMAlterTriggerRequest(const WMAlterTriggerRequest& other1492) { + trigger = other1492.trigger; + __isset = other1492.__isset; +} +WMAlterTriggerRequest& WMAlterTriggerRequest::operator=(const WMAlterTriggerRequest& other1493) { + trigger = other1493.trigger; + __isset = other1493.__isset; + return *this; +} +void WMAlterTriggerRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMAlterTriggerRequest("; + out << "trigger="; (__isset.trigger ? (out << to_string(trigger)) : (out << "")); + out << ")"; +} + + +WMAlterTriggerResponse::~WMAlterTriggerResponse() noexcept { +} + +WMAlterTriggerResponse::WMAlterTriggerResponse() noexcept { +} +std::ostream& operator<<(std::ostream& out, const WMAlterTriggerResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMAlterTriggerResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMAlterTriggerResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMAlterTriggerResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMAlterTriggerResponse &a, WMAlterTriggerResponse &b) noexcept { + using ::std::swap; + (void) a; + (void) b; +} + +bool WMAlterTriggerResponse::operator==(const WMAlterTriggerResponse & /* rhs */) const +{ + return true; +} + +WMAlterTriggerResponse::WMAlterTriggerResponse(const WMAlterTriggerResponse& other1494) noexcept { + (void) other1494; +} +WMAlterTriggerResponse& WMAlterTriggerResponse::operator=(const WMAlterTriggerResponse& other1495) noexcept { + (void) other1495; + return *this; +} +void WMAlterTriggerResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMAlterTriggerResponse("; + out << ")"; +} + + +WMDropTriggerRequest::~WMDropTriggerRequest() noexcept { +} + +WMDropTriggerRequest::WMDropTriggerRequest() noexcept + : resourcePlanName(), + triggerName(), + ns() { +} + +void WMDropTriggerRequest::__set_resourcePlanName(const std::string& val) { + this->resourcePlanName = val; +__isset.resourcePlanName = true; +} + +void WMDropTriggerRequest::__set_triggerName(const std::string& val) { + this->triggerName = val; +__isset.triggerName = true; +} + +void WMDropTriggerRequest::__set_ns(const std::string& val) { + this->ns = val; +__isset.ns = true; +} +std::ostream& operator<<(std::ostream& out, const WMDropTriggerRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMDropTriggerRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->resourcePlanName); + this->__isset.resourcePlanName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->triggerName); + this->__isset.triggerName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ns); + this->__isset.ns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMDropTriggerRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMDropTriggerRequest"); + + if (this->__isset.resourcePlanName) { + xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->resourcePlanName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.triggerName) { + xfer += oprot->writeFieldBegin("triggerName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->triggerName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ns) { + xfer += oprot->writeFieldBegin("ns", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->ns); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMDropTriggerRequest &a, WMDropTriggerRequest &b) noexcept { + using ::std::swap; + swap(a.resourcePlanName, b.resourcePlanName); + swap(a.triggerName, b.triggerName); + swap(a.ns, b.ns); + swap(a.__isset, b.__isset); +} + +bool WMDropTriggerRequest::operator==(const WMDropTriggerRequest & rhs) const +{ + if (__isset.resourcePlanName != rhs.__isset.resourcePlanName) + return false; + else if (__isset.resourcePlanName && !(resourcePlanName == rhs.resourcePlanName)) + return false; + if (__isset.triggerName != rhs.__isset.triggerName) + return false; + else if (__isset.triggerName && !(triggerName == rhs.triggerName)) + return false; + if (__isset.ns != rhs.__isset.ns) + return false; + else if (__isset.ns && !(ns == rhs.ns)) + return false; + return true; +} + +WMDropTriggerRequest::WMDropTriggerRequest(const WMDropTriggerRequest& other1496) { + resourcePlanName = other1496.resourcePlanName; + triggerName = other1496.triggerName; + ns = other1496.ns; + __isset = other1496.__isset; +} +WMDropTriggerRequest& WMDropTriggerRequest::operator=(const WMDropTriggerRequest& other1497) { + resourcePlanName = other1497.resourcePlanName; + triggerName = other1497.triggerName; + ns = other1497.ns; + __isset = other1497.__isset; + return *this; +} +void WMDropTriggerRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMDropTriggerRequest("; + out << "resourcePlanName="; (__isset.resourcePlanName ? (out << to_string(resourcePlanName)) : (out << "")); + out << ", " << "triggerName="; (__isset.triggerName ? (out << to_string(triggerName)) : (out << "")); + out << ", " << "ns="; (__isset.ns ? (out << to_string(ns)) : (out << "")); + out << ")"; +} + + +WMDropTriggerResponse::~WMDropTriggerResponse() noexcept { +} + +WMDropTriggerResponse::WMDropTriggerResponse() noexcept { +} +std::ostream& operator<<(std::ostream& out, const WMDropTriggerResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMDropTriggerResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMDropTriggerResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMDropTriggerResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMDropTriggerResponse &a, WMDropTriggerResponse &b) noexcept { + using ::std::swap; + (void) a; + (void) b; +} + +bool WMDropTriggerResponse::operator==(const WMDropTriggerResponse & /* rhs */) const +{ + return true; +} + +WMDropTriggerResponse::WMDropTriggerResponse(const WMDropTriggerResponse& other1498) noexcept { + (void) other1498; +} +WMDropTriggerResponse& WMDropTriggerResponse::operator=(const WMDropTriggerResponse& other1499) noexcept { + (void) other1499; + return *this; +} +void WMDropTriggerResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMDropTriggerResponse("; + out << ")"; +} + + +WMGetTriggersForResourePlanRequest::~WMGetTriggersForResourePlanRequest() noexcept { +} + +WMGetTriggersForResourePlanRequest::WMGetTriggersForResourePlanRequest() noexcept + : resourcePlanName(), + ns() { +} + +void WMGetTriggersForResourePlanRequest::__set_resourcePlanName(const std::string& val) { + this->resourcePlanName = val; +__isset.resourcePlanName = true; +} + +void WMGetTriggersForResourePlanRequest::__set_ns(const std::string& val) { + this->ns = val; +__isset.ns = true; +} +std::ostream& operator<<(std::ostream& out, const WMGetTriggersForResourePlanRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMGetTriggersForResourePlanRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->resourcePlanName); + this->__isset.resourcePlanName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ns); + this->__isset.ns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMGetTriggersForResourePlanRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMGetTriggersForResourePlanRequest"); + + if (this->__isset.resourcePlanName) { + xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->resourcePlanName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ns) { + xfer += oprot->writeFieldBegin("ns", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->ns); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMGetTriggersForResourePlanRequest &a, WMGetTriggersForResourePlanRequest &b) noexcept { + using ::std::swap; + swap(a.resourcePlanName, b.resourcePlanName); + swap(a.ns, b.ns); + swap(a.__isset, b.__isset); +} + +bool WMGetTriggersForResourePlanRequest::operator==(const WMGetTriggersForResourePlanRequest & rhs) const +{ + if (__isset.resourcePlanName != rhs.__isset.resourcePlanName) + return false; + else if (__isset.resourcePlanName && !(resourcePlanName == rhs.resourcePlanName)) + return false; + if (__isset.ns != rhs.__isset.ns) + return false; + else if (__isset.ns && !(ns == rhs.ns)) + return false; + return true; +} + +WMGetTriggersForResourePlanRequest::WMGetTriggersForResourePlanRequest(const WMGetTriggersForResourePlanRequest& other1500) { + resourcePlanName = other1500.resourcePlanName; + ns = other1500.ns; + __isset = other1500.__isset; +} +WMGetTriggersForResourePlanRequest& WMGetTriggersForResourePlanRequest::operator=(const WMGetTriggersForResourePlanRequest& other1501) { + resourcePlanName = other1501.resourcePlanName; + ns = other1501.ns; + __isset = other1501.__isset; + return *this; +} +void WMGetTriggersForResourePlanRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMGetTriggersForResourePlanRequest("; + out << "resourcePlanName="; (__isset.resourcePlanName ? (out << to_string(resourcePlanName)) : (out << "")); + out << ", " << "ns="; (__isset.ns ? (out << to_string(ns)) : (out << "")); + out << ")"; +} + + +WMGetTriggersForResourePlanResponse::~WMGetTriggersForResourePlanResponse() noexcept { +} + +WMGetTriggersForResourePlanResponse::WMGetTriggersForResourePlanResponse() noexcept { +} + +void WMGetTriggersForResourePlanResponse::__set_triggers(const std::vector & val) { + this->triggers = val; +__isset.triggers = true; +} +std::ostream& operator<<(std::ostream& out, const WMGetTriggersForResourePlanResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMGetTriggersForResourePlanResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->triggers.clear(); + uint32_t _size1502; + ::apache::thrift::protocol::TType _etype1505; + xfer += iprot->readListBegin(_etype1505, _size1502); + this->triggers.resize(_size1502); + uint32_t _i1506; + for (_i1506 = 0; _i1506 < _size1502; ++_i1506) + { + xfer += this->triggers[_i1506].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.triggers = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMGetTriggersForResourePlanResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMGetTriggersForResourePlanResponse"); + + if (this->__isset.triggers) { + xfer += oprot->writeFieldBegin("triggers", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->triggers.size())); + std::vector ::const_iterator _iter1507; + for (_iter1507 = this->triggers.begin(); _iter1507 != this->triggers.end(); ++_iter1507) + { + xfer += (*_iter1507).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMGetTriggersForResourePlanResponse &a, WMGetTriggersForResourePlanResponse &b) noexcept { + using ::std::swap; + swap(a.triggers, b.triggers); + swap(a.__isset, b.__isset); +} + +bool WMGetTriggersForResourePlanResponse::operator==(const WMGetTriggersForResourePlanResponse & rhs) const +{ + if (__isset.triggers != rhs.__isset.triggers) + return false; + else if (__isset.triggers && !(triggers == rhs.triggers)) + return false; + return true; +} + +WMGetTriggersForResourePlanResponse::WMGetTriggersForResourePlanResponse(const WMGetTriggersForResourePlanResponse& other1508) { + triggers = other1508.triggers; + __isset = other1508.__isset; +} +WMGetTriggersForResourePlanResponse& WMGetTriggersForResourePlanResponse::operator=(const WMGetTriggersForResourePlanResponse& other1509) { + triggers = other1509.triggers; + __isset = other1509.__isset; + return *this; +} +void WMGetTriggersForResourePlanResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMGetTriggersForResourePlanResponse("; + out << "triggers="; (__isset.triggers ? (out << to_string(triggers)) : (out << "")); + out << ")"; +} + + +WMCreatePoolRequest::~WMCreatePoolRequest() noexcept { +} + +WMCreatePoolRequest::WMCreatePoolRequest() noexcept { +} + +void WMCreatePoolRequest::__set_pool(const WMPool& val) { + this->pool = val; +__isset.pool = true; +} +std::ostream& operator<<(std::ostream& out, const WMCreatePoolRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMCreatePoolRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->pool.read(iprot); + this->__isset.pool = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMCreatePoolRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMCreatePoolRequest"); + + if (this->__isset.pool) { + xfer += oprot->writeFieldBegin("pool", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->pool.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMCreatePoolRequest &a, WMCreatePoolRequest &b) noexcept { + using ::std::swap; + swap(a.pool, b.pool); + swap(a.__isset, b.__isset); +} + +bool WMCreatePoolRequest::operator==(const WMCreatePoolRequest & rhs) const +{ + if (__isset.pool != rhs.__isset.pool) + return false; + else if (__isset.pool && !(pool == rhs.pool)) + return false; + return true; +} + +WMCreatePoolRequest::WMCreatePoolRequest(const WMCreatePoolRequest& other1510) { + pool = other1510.pool; + __isset = other1510.__isset; +} +WMCreatePoolRequest& WMCreatePoolRequest::operator=(const WMCreatePoolRequest& other1511) { + pool = other1511.pool; + __isset = other1511.__isset; + return *this; +} +void WMCreatePoolRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMCreatePoolRequest("; + out << "pool="; (__isset.pool ? (out << to_string(pool)) : (out << "")); + out << ")"; +} + + +WMCreatePoolResponse::~WMCreatePoolResponse() noexcept { +} + +WMCreatePoolResponse::WMCreatePoolResponse() noexcept { +} +std::ostream& operator<<(std::ostream& out, const WMCreatePoolResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMCreatePoolResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMCreatePoolResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMCreatePoolResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMCreatePoolResponse &a, WMCreatePoolResponse &b) noexcept { + using ::std::swap; + (void) a; + (void) b; +} + +bool WMCreatePoolResponse::operator==(const WMCreatePoolResponse & /* rhs */) const +{ + return true; +} + +WMCreatePoolResponse::WMCreatePoolResponse(const WMCreatePoolResponse& other1512) noexcept { + (void) other1512; +} +WMCreatePoolResponse& WMCreatePoolResponse::operator=(const WMCreatePoolResponse& other1513) noexcept { + (void) other1513; + return *this; +} +void WMCreatePoolResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMCreatePoolResponse("; + out << ")"; +} + + +WMAlterPoolRequest::~WMAlterPoolRequest() noexcept { +} + +WMAlterPoolRequest::WMAlterPoolRequest() noexcept + : poolPath() { +} + +void WMAlterPoolRequest::__set_pool(const WMNullablePool& val) { + this->pool = val; +__isset.pool = true; +} + +void WMAlterPoolRequest::__set_poolPath(const std::string& val) { + this->poolPath = val; +__isset.poolPath = true; +} +std::ostream& operator<<(std::ostream& out, const WMAlterPoolRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMAlterPoolRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->pool.read(iprot); + this->__isset.pool = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->poolPath); + this->__isset.poolPath = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMAlterPoolRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMAlterPoolRequest"); + + if (this->__isset.pool) { + xfer += oprot->writeFieldBegin("pool", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->pool.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.poolPath) { + xfer += oprot->writeFieldBegin("poolPath", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->poolPath); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMAlterPoolRequest &a, WMAlterPoolRequest &b) noexcept { + using ::std::swap; + swap(a.pool, b.pool); + swap(a.poolPath, b.poolPath); + swap(a.__isset, b.__isset); +} + +bool WMAlterPoolRequest::operator==(const WMAlterPoolRequest & rhs) const +{ + if (__isset.pool != rhs.__isset.pool) + return false; + else if (__isset.pool && !(pool == rhs.pool)) + return false; + if (__isset.poolPath != rhs.__isset.poolPath) + return false; + else if (__isset.poolPath && !(poolPath == rhs.poolPath)) + return false; + return true; +} + +WMAlterPoolRequest::WMAlterPoolRequest(const WMAlterPoolRequest& other1514) { + pool = other1514.pool; + poolPath = other1514.poolPath; + __isset = other1514.__isset; +} +WMAlterPoolRequest& WMAlterPoolRequest::operator=(const WMAlterPoolRequest& other1515) { + pool = other1515.pool; + poolPath = other1515.poolPath; + __isset = other1515.__isset; + return *this; +} +void WMAlterPoolRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMAlterPoolRequest("; + out << "pool="; (__isset.pool ? (out << to_string(pool)) : (out << "")); + out << ", " << "poolPath="; (__isset.poolPath ? (out << to_string(poolPath)) : (out << "")); + out << ")"; +} + + +WMAlterPoolResponse::~WMAlterPoolResponse() noexcept { +} + +WMAlterPoolResponse::WMAlterPoolResponse() noexcept { +} +std::ostream& operator<<(std::ostream& out, const WMAlterPoolResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMAlterPoolResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMAlterPoolResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMAlterPoolResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMAlterPoolResponse &a, WMAlterPoolResponse &b) noexcept { + using ::std::swap; + (void) a; + (void) b; +} + +bool WMAlterPoolResponse::operator==(const WMAlterPoolResponse & /* rhs */) const +{ + return true; +} + +WMAlterPoolResponse::WMAlterPoolResponse(const WMAlterPoolResponse& other1516) noexcept { + (void) other1516; +} +WMAlterPoolResponse& WMAlterPoolResponse::operator=(const WMAlterPoolResponse& other1517) noexcept { + (void) other1517; + return *this; +} +void WMAlterPoolResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMAlterPoolResponse("; + out << ")"; +} + + +WMDropPoolRequest::~WMDropPoolRequest() noexcept { +} + +WMDropPoolRequest::WMDropPoolRequest() noexcept + : resourcePlanName(), + poolPath(), + ns() { +} + +void WMDropPoolRequest::__set_resourcePlanName(const std::string& val) { + this->resourcePlanName = val; +__isset.resourcePlanName = true; +} + +void WMDropPoolRequest::__set_poolPath(const std::string& val) { + this->poolPath = val; +__isset.poolPath = true; +} + +void WMDropPoolRequest::__set_ns(const std::string& val) { + this->ns = val; +__isset.ns = true; +} +std::ostream& operator<<(std::ostream& out, const WMDropPoolRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMDropPoolRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->resourcePlanName); + this->__isset.resourcePlanName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->poolPath); + this->__isset.poolPath = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ns); + this->__isset.ns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMDropPoolRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMDropPoolRequest"); + + if (this->__isset.resourcePlanName) { + xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->resourcePlanName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.poolPath) { + xfer += oprot->writeFieldBegin("poolPath", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->poolPath); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ns) { + xfer += oprot->writeFieldBegin("ns", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->ns); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMDropPoolRequest &a, WMDropPoolRequest &b) noexcept { + using ::std::swap; + swap(a.resourcePlanName, b.resourcePlanName); + swap(a.poolPath, b.poolPath); + swap(a.ns, b.ns); + swap(a.__isset, b.__isset); +} + +bool WMDropPoolRequest::operator==(const WMDropPoolRequest & rhs) const +{ + if (__isset.resourcePlanName != rhs.__isset.resourcePlanName) + return false; + else if (__isset.resourcePlanName && !(resourcePlanName == rhs.resourcePlanName)) + return false; + if (__isset.poolPath != rhs.__isset.poolPath) + return false; + else if (__isset.poolPath && !(poolPath == rhs.poolPath)) + return false; + if (__isset.ns != rhs.__isset.ns) + return false; + else if (__isset.ns && !(ns == rhs.ns)) + return false; + return true; +} + +WMDropPoolRequest::WMDropPoolRequest(const WMDropPoolRequest& other1518) { + resourcePlanName = other1518.resourcePlanName; + poolPath = other1518.poolPath; + ns = other1518.ns; + __isset = other1518.__isset; +} +WMDropPoolRequest& WMDropPoolRequest::operator=(const WMDropPoolRequest& other1519) { + resourcePlanName = other1519.resourcePlanName; + poolPath = other1519.poolPath; + ns = other1519.ns; + __isset = other1519.__isset; + return *this; +} +void WMDropPoolRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMDropPoolRequest("; + out << "resourcePlanName="; (__isset.resourcePlanName ? (out << to_string(resourcePlanName)) : (out << "")); + out << ", " << "poolPath="; (__isset.poolPath ? (out << to_string(poolPath)) : (out << "")); + out << ", " << "ns="; (__isset.ns ? (out << to_string(ns)) : (out << "")); + out << ")"; +} + + +WMDropPoolResponse::~WMDropPoolResponse() noexcept { +} + +WMDropPoolResponse::WMDropPoolResponse() noexcept { +} +std::ostream& operator<<(std::ostream& out, const WMDropPoolResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMDropPoolResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMDropPoolResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMDropPoolResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMDropPoolResponse &a, WMDropPoolResponse &b) noexcept { + using ::std::swap; + (void) a; + (void) b; +} + +bool WMDropPoolResponse::operator==(const WMDropPoolResponse & /* rhs */) const +{ + return true; +} + +WMDropPoolResponse::WMDropPoolResponse(const WMDropPoolResponse& other1520) noexcept { + (void) other1520; +} +WMDropPoolResponse& WMDropPoolResponse::operator=(const WMDropPoolResponse& other1521) noexcept { + (void) other1521; + return *this; +} +void WMDropPoolResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMDropPoolResponse("; + out << ")"; +} + + +WMCreateOrUpdateMappingRequest::~WMCreateOrUpdateMappingRequest() noexcept { +} + +WMCreateOrUpdateMappingRequest::WMCreateOrUpdateMappingRequest() noexcept + : update(0) { +} + +void WMCreateOrUpdateMappingRequest::__set_mapping(const WMMapping& val) { + this->mapping = val; +__isset.mapping = true; +} + +void WMCreateOrUpdateMappingRequest::__set_update(const bool val) { + this->update = val; +__isset.update = true; +} +std::ostream& operator<<(std::ostream& out, const WMCreateOrUpdateMappingRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMCreateOrUpdateMappingRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->mapping.read(iprot); + this->__isset.mapping = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->update); + this->__isset.update = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMCreateOrUpdateMappingRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMCreateOrUpdateMappingRequest"); + + if (this->__isset.mapping) { + xfer += oprot->writeFieldBegin("mapping", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->mapping.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.update) { + xfer += oprot->writeFieldBegin("update", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool(this->update); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMCreateOrUpdateMappingRequest &a, WMCreateOrUpdateMappingRequest &b) noexcept { + using ::std::swap; + swap(a.mapping, b.mapping); + swap(a.update, b.update); + swap(a.__isset, b.__isset); +} + +bool WMCreateOrUpdateMappingRequest::operator==(const WMCreateOrUpdateMappingRequest & rhs) const +{ + if (__isset.mapping != rhs.__isset.mapping) + return false; + else if (__isset.mapping && !(mapping == rhs.mapping)) + return false; + if (__isset.update != rhs.__isset.update) + return false; + else if (__isset.update && !(update == rhs.update)) + return false; + return true; +} + +WMCreateOrUpdateMappingRequest::WMCreateOrUpdateMappingRequest(const WMCreateOrUpdateMappingRequest& other1522) { + mapping = other1522.mapping; + update = other1522.update; + __isset = other1522.__isset; +} +WMCreateOrUpdateMappingRequest& WMCreateOrUpdateMappingRequest::operator=(const WMCreateOrUpdateMappingRequest& other1523) { + mapping = other1523.mapping; + update = other1523.update; + __isset = other1523.__isset; + return *this; +} +void WMCreateOrUpdateMappingRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMCreateOrUpdateMappingRequest("; + out << "mapping="; (__isset.mapping ? (out << to_string(mapping)) : (out << "")); + out << ", " << "update="; (__isset.update ? (out << to_string(update)) : (out << "")); + out << ")"; +} + + +WMCreateOrUpdateMappingResponse::~WMCreateOrUpdateMappingResponse() noexcept { +} + +WMCreateOrUpdateMappingResponse::WMCreateOrUpdateMappingResponse() noexcept { +} +std::ostream& operator<<(std::ostream& out, const WMCreateOrUpdateMappingResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMCreateOrUpdateMappingResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMCreateOrUpdateMappingResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMCreateOrUpdateMappingResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMCreateOrUpdateMappingResponse &a, WMCreateOrUpdateMappingResponse &b) noexcept { + using ::std::swap; + (void) a; + (void) b; +} + +bool WMCreateOrUpdateMappingResponse::operator==(const WMCreateOrUpdateMappingResponse & /* rhs */) const +{ + return true; +} + +WMCreateOrUpdateMappingResponse::WMCreateOrUpdateMappingResponse(const WMCreateOrUpdateMappingResponse& other1524) noexcept { + (void) other1524; +} +WMCreateOrUpdateMappingResponse& WMCreateOrUpdateMappingResponse::operator=(const WMCreateOrUpdateMappingResponse& other1525) noexcept { + (void) other1525; + return *this; +} +void WMCreateOrUpdateMappingResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMCreateOrUpdateMappingResponse("; + out << ")"; +} + + +WMDropMappingRequest::~WMDropMappingRequest() noexcept { +} + +WMDropMappingRequest::WMDropMappingRequest() noexcept { +} + +void WMDropMappingRequest::__set_mapping(const WMMapping& val) { + this->mapping = val; +__isset.mapping = true; +} +std::ostream& operator<<(std::ostream& out, const WMDropMappingRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMDropMappingRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->mapping.read(iprot); + this->__isset.mapping = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMDropMappingRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMDropMappingRequest"); + + if (this->__isset.mapping) { + xfer += oprot->writeFieldBegin("mapping", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->mapping.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMDropMappingRequest &a, WMDropMappingRequest &b) noexcept { + using ::std::swap; + swap(a.mapping, b.mapping); + swap(a.__isset, b.__isset); +} + +bool WMDropMappingRequest::operator==(const WMDropMappingRequest & rhs) const +{ + if (__isset.mapping != rhs.__isset.mapping) + return false; + else if (__isset.mapping && !(mapping == rhs.mapping)) + return false; + return true; +} + +WMDropMappingRequest::WMDropMappingRequest(const WMDropMappingRequest& other1526) { + mapping = other1526.mapping; + __isset = other1526.__isset; +} +WMDropMappingRequest& WMDropMappingRequest::operator=(const WMDropMappingRequest& other1527) { + mapping = other1527.mapping; + __isset = other1527.__isset; + return *this; +} +void WMDropMappingRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMDropMappingRequest("; + out << "mapping="; (__isset.mapping ? (out << to_string(mapping)) : (out << "")); + out << ")"; +} + + +WMDropMappingResponse::~WMDropMappingResponse() noexcept { +} + +WMDropMappingResponse::WMDropMappingResponse() noexcept { +} +std::ostream& operator<<(std::ostream& out, const WMDropMappingResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMDropMappingResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMDropMappingResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMDropMappingResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMDropMappingResponse &a, WMDropMappingResponse &b) noexcept { + using ::std::swap; + (void) a; + (void) b; +} + +bool WMDropMappingResponse::operator==(const WMDropMappingResponse & /* rhs */) const +{ + return true; +} + +WMDropMappingResponse::WMDropMappingResponse(const WMDropMappingResponse& other1528) noexcept { + (void) other1528; +} +WMDropMappingResponse& WMDropMappingResponse::operator=(const WMDropMappingResponse& other1529) noexcept { + (void) other1529; + return *this; +} +void WMDropMappingResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMDropMappingResponse("; + out << ")"; +} + + +WMCreateOrDropTriggerToPoolMappingRequest::~WMCreateOrDropTriggerToPoolMappingRequest() noexcept { +} + +WMCreateOrDropTriggerToPoolMappingRequest::WMCreateOrDropTriggerToPoolMappingRequest() noexcept + : resourcePlanName(), + triggerName(), + poolPath(), + drop(0), + ns() { +} + +void WMCreateOrDropTriggerToPoolMappingRequest::__set_resourcePlanName(const std::string& val) { + this->resourcePlanName = val; +__isset.resourcePlanName = true; +} + +void WMCreateOrDropTriggerToPoolMappingRequest::__set_triggerName(const std::string& val) { + this->triggerName = val; +__isset.triggerName = true; +} + +void WMCreateOrDropTriggerToPoolMappingRequest::__set_poolPath(const std::string& val) { + this->poolPath = val; +__isset.poolPath = true; +} + +void WMCreateOrDropTriggerToPoolMappingRequest::__set_drop(const bool val) { + this->drop = val; +__isset.drop = true; +} + +void WMCreateOrDropTriggerToPoolMappingRequest::__set_ns(const std::string& val) { + this->ns = val; +__isset.ns = true; +} +std::ostream& operator<<(std::ostream& out, const WMCreateOrDropTriggerToPoolMappingRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMCreateOrDropTriggerToPoolMappingRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->resourcePlanName); + this->__isset.resourcePlanName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->triggerName); + this->__isset.triggerName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->poolPath); + this->__isset.poolPath = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->drop); + this->__isset.drop = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ns); + this->__isset.ns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMCreateOrDropTriggerToPoolMappingRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMCreateOrDropTriggerToPoolMappingRequest"); + + if (this->__isset.resourcePlanName) { + xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->resourcePlanName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.triggerName) { + xfer += oprot->writeFieldBegin("triggerName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->triggerName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.poolPath) { + xfer += oprot->writeFieldBegin("poolPath", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->poolPath); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.drop) { + xfer += oprot->writeFieldBegin("drop", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool(this->drop); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ns) { + xfer += oprot->writeFieldBegin("ns", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->ns); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMCreateOrDropTriggerToPoolMappingRequest &a, WMCreateOrDropTriggerToPoolMappingRequest &b) noexcept { + using ::std::swap; + swap(a.resourcePlanName, b.resourcePlanName); + swap(a.triggerName, b.triggerName); + swap(a.poolPath, b.poolPath); + swap(a.drop, b.drop); + swap(a.ns, b.ns); + swap(a.__isset, b.__isset); +} + +bool WMCreateOrDropTriggerToPoolMappingRequest::operator==(const WMCreateOrDropTriggerToPoolMappingRequest & rhs) const +{ + if (__isset.resourcePlanName != rhs.__isset.resourcePlanName) + return false; + else if (__isset.resourcePlanName && !(resourcePlanName == rhs.resourcePlanName)) + return false; + if (__isset.triggerName != rhs.__isset.triggerName) + return false; + else if (__isset.triggerName && !(triggerName == rhs.triggerName)) + return false; + if (__isset.poolPath != rhs.__isset.poolPath) + return false; + else if (__isset.poolPath && !(poolPath == rhs.poolPath)) + return false; + if (__isset.drop != rhs.__isset.drop) + return false; + else if (__isset.drop && !(drop == rhs.drop)) + return false; + if (__isset.ns != rhs.__isset.ns) + return false; + else if (__isset.ns && !(ns == rhs.ns)) + return false; + return true; +} + +WMCreateOrDropTriggerToPoolMappingRequest::WMCreateOrDropTriggerToPoolMappingRequest(const WMCreateOrDropTriggerToPoolMappingRequest& other1530) { + resourcePlanName = other1530.resourcePlanName; + triggerName = other1530.triggerName; + poolPath = other1530.poolPath; + drop = other1530.drop; + ns = other1530.ns; + __isset = other1530.__isset; +} +WMCreateOrDropTriggerToPoolMappingRequest& WMCreateOrDropTriggerToPoolMappingRequest::operator=(const WMCreateOrDropTriggerToPoolMappingRequest& other1531) { + resourcePlanName = other1531.resourcePlanName; + triggerName = other1531.triggerName; + poolPath = other1531.poolPath; + drop = other1531.drop; + ns = other1531.ns; + __isset = other1531.__isset; + return *this; +} +void WMCreateOrDropTriggerToPoolMappingRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMCreateOrDropTriggerToPoolMappingRequest("; + out << "resourcePlanName="; (__isset.resourcePlanName ? (out << to_string(resourcePlanName)) : (out << "")); + out << ", " << "triggerName="; (__isset.triggerName ? (out << to_string(triggerName)) : (out << "")); + out << ", " << "poolPath="; (__isset.poolPath ? (out << to_string(poolPath)) : (out << "")); + out << ", " << "drop="; (__isset.drop ? (out << to_string(drop)) : (out << "")); + out << ", " << "ns="; (__isset.ns ? (out << to_string(ns)) : (out << "")); + out << ")"; +} + + +WMCreateOrDropTriggerToPoolMappingResponse::~WMCreateOrDropTriggerToPoolMappingResponse() noexcept { +} + +WMCreateOrDropTriggerToPoolMappingResponse::WMCreateOrDropTriggerToPoolMappingResponse() noexcept { +} +std::ostream& operator<<(std::ostream& out, const WMCreateOrDropTriggerToPoolMappingResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t WMCreateOrDropTriggerToPoolMappingResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMCreateOrDropTriggerToPoolMappingResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMCreateOrDropTriggerToPoolMappingResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMCreateOrDropTriggerToPoolMappingResponse &a, WMCreateOrDropTriggerToPoolMappingResponse &b) noexcept { + using ::std::swap; + (void) a; + (void) b; +} + +bool WMCreateOrDropTriggerToPoolMappingResponse::operator==(const WMCreateOrDropTriggerToPoolMappingResponse & /* rhs */) const +{ + return true; +} + +WMCreateOrDropTriggerToPoolMappingResponse::WMCreateOrDropTriggerToPoolMappingResponse(const WMCreateOrDropTriggerToPoolMappingResponse& other1532) noexcept { + (void) other1532; +} +WMCreateOrDropTriggerToPoolMappingResponse& WMCreateOrDropTriggerToPoolMappingResponse::operator=(const WMCreateOrDropTriggerToPoolMappingResponse& other1533) noexcept { + (void) other1533; + return *this; +} +void WMCreateOrDropTriggerToPoolMappingResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMCreateOrDropTriggerToPoolMappingResponse("; + out << ")"; +} + + +ISchema::~ISchema() noexcept { +} + +ISchema::ISchema() noexcept + : schemaType(static_cast(0)), + name(), + catName(), + dbName(), + compatibility(static_cast(0)), + validationLevel(static_cast(0)), + canEvolve(0), + schemaGroup(), + description() { +} + +void ISchema::__set_schemaType(const SchemaType::type val) { + this->schemaType = val; +} + +void ISchema::__set_name(const std::string& val) { + this->name = val; +} + +void ISchema::__set_catName(const std::string& val) { + this->catName = val; +} + +void ISchema::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void ISchema::__set_compatibility(const SchemaCompatibility::type val) { + this->compatibility = val; +} + +void ISchema::__set_validationLevel(const SchemaValidation::type val) { + this->validationLevel = val; +} + +void ISchema::__set_canEvolve(const bool val) { + this->canEvolve = val; +} + +void ISchema::__set_schemaGroup(const std::string& val) { + this->schemaGroup = val; +__isset.schemaGroup = true; +} + +void ISchema::__set_description(const std::string& val) { + this->description = val; +__isset.description = true; +} +std::ostream& operator<<(std::ostream& out, const ISchema& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ISchema::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1534; + xfer += iprot->readI32(ecast1534); + this->schemaType = static_cast(ecast1534); + this->__isset.schemaType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1535; + xfer += iprot->readI32(ecast1535); + this->compatibility = static_cast(ecast1535); + this->__isset.compatibility = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1536; + xfer += iprot->readI32(ecast1536); + this->validationLevel = static_cast(ecast1536); + this->__isset.validationLevel = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->canEvolve); + this->__isset.canEvolve = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->schemaGroup); + this->__isset.schemaGroup = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->description); + this->__isset.description = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ISchema::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ISchema"); + + xfer += oprot->writeFieldBegin("schemaType", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32(static_cast(this->schemaType)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("compatibility", ::apache::thrift::protocol::T_I32, 5); + xfer += oprot->writeI32(static_cast(this->compatibility)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("validationLevel", ::apache::thrift::protocol::T_I32, 6); + xfer += oprot->writeI32(static_cast(this->validationLevel)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("canEvolve", ::apache::thrift::protocol::T_BOOL, 7); + xfer += oprot->writeBool(this->canEvolve); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.schemaGroup) { + xfer += oprot->writeFieldBegin("schemaGroup", ::apache::thrift::protocol::T_STRING, 8); + xfer += oprot->writeString(this->schemaGroup); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.description) { + xfer += oprot->writeFieldBegin("description", ::apache::thrift::protocol::T_STRING, 9); + xfer += oprot->writeString(this->description); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ISchema &a, ISchema &b) noexcept { + using ::std::swap; + swap(a.schemaType, b.schemaType); + swap(a.name, b.name); + swap(a.catName, b.catName); + swap(a.dbName, b.dbName); + swap(a.compatibility, b.compatibility); + swap(a.validationLevel, b.validationLevel); + swap(a.canEvolve, b.canEvolve); + swap(a.schemaGroup, b.schemaGroup); + swap(a.description, b.description); + swap(a.__isset, b.__isset); +} + +bool ISchema::operator==(const ISchema & rhs) const +{ + if (!(schemaType == rhs.schemaType)) + return false; + if (!(name == rhs.name)) + return false; + if (!(catName == rhs.catName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(compatibility == rhs.compatibility)) + return false; + if (!(validationLevel == rhs.validationLevel)) + return false; + if (!(canEvolve == rhs.canEvolve)) + return false; + if (__isset.schemaGroup != rhs.__isset.schemaGroup) + return false; + else if (__isset.schemaGroup && !(schemaGroup == rhs.schemaGroup)) + return false; + if (__isset.description != rhs.__isset.description) + return false; + else if (__isset.description && !(description == rhs.description)) + return false; + return true; +} + +ISchema::ISchema(const ISchema& other1537) { + schemaType = other1537.schemaType; + name = other1537.name; + catName = other1537.catName; + dbName = other1537.dbName; + compatibility = other1537.compatibility; + validationLevel = other1537.validationLevel; + canEvolve = other1537.canEvolve; + schemaGroup = other1537.schemaGroup; + description = other1537.description; + __isset = other1537.__isset; +} +ISchema& ISchema::operator=(const ISchema& other1538) { + schemaType = other1538.schemaType; + name = other1538.name; + catName = other1538.catName; + dbName = other1538.dbName; + compatibility = other1538.compatibility; + validationLevel = other1538.validationLevel; + canEvolve = other1538.canEvolve; + schemaGroup = other1538.schemaGroup; + description = other1538.description; + __isset = other1538.__isset; + return *this; +} +void ISchema::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ISchema("; + out << "schemaType=" << to_string(schemaType); + out << ", " << "name=" << to_string(name); + out << ", " << "catName=" << to_string(catName); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "compatibility=" << to_string(compatibility); + out << ", " << "validationLevel=" << to_string(validationLevel); + out << ", " << "canEvolve=" << to_string(canEvolve); + out << ", " << "schemaGroup="; (__isset.schemaGroup ? (out << to_string(schemaGroup)) : (out << "")); + out << ", " << "description="; (__isset.description ? (out << to_string(description)) : (out << "")); + out << ")"; +} + + +ISchemaName::~ISchemaName() noexcept { +} + +ISchemaName::ISchemaName() noexcept + : catName(), + dbName(), + schemaName() { +} + +void ISchemaName::__set_catName(const std::string& val) { + this->catName = val; +} + +void ISchemaName::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void ISchemaName::__set_schemaName(const std::string& val) { + this->schemaName = val; +} +std::ostream& operator<<(std::ostream& out, const ISchemaName& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ISchemaName::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->schemaName); + this->__isset.schemaName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ISchemaName::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ISchemaName"); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("schemaName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->schemaName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ISchemaName &a, ISchemaName &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.dbName, b.dbName); + swap(a.schemaName, b.schemaName); + swap(a.__isset, b.__isset); +} + +bool ISchemaName::operator==(const ISchemaName & rhs) const +{ + if (!(catName == rhs.catName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(schemaName == rhs.schemaName)) + return false; + return true; +} + +ISchemaName::ISchemaName(const ISchemaName& other1539) { + catName = other1539.catName; + dbName = other1539.dbName; + schemaName = other1539.schemaName; + __isset = other1539.__isset; +} +ISchemaName& ISchemaName::operator=(const ISchemaName& other1540) { + catName = other1540.catName; + dbName = other1540.dbName; + schemaName = other1540.schemaName; + __isset = other1540.__isset; + return *this; +} +void ISchemaName::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ISchemaName("; + out << "catName=" << to_string(catName); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "schemaName=" << to_string(schemaName); + out << ")"; +} + + +AlterISchemaRequest::~AlterISchemaRequest() noexcept { +} + +AlterISchemaRequest::AlterISchemaRequest() noexcept { +} + +void AlterISchemaRequest::__set_name(const ISchemaName& val) { + this->name = val; +} + +void AlterISchemaRequest::__set_newSchema(const ISchema& val) { + this->newSchema = val; +} +std::ostream& operator<<(std::ostream& out, const AlterISchemaRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AlterISchemaRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->name.read(iprot); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->newSchema.read(iprot); + this->__isset.newSchema = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t AlterISchemaRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AlterISchemaRequest"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->name.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("newSchema", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->newSchema.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AlterISchemaRequest &a, AlterISchemaRequest &b) noexcept { + using ::std::swap; + swap(a.name, b.name); + swap(a.newSchema, b.newSchema); + swap(a.__isset, b.__isset); +} + +bool AlterISchemaRequest::operator==(const AlterISchemaRequest & rhs) const +{ + if (!(name == rhs.name)) + return false; + if (!(newSchema == rhs.newSchema)) + return false; + return true; +} + +AlterISchemaRequest::AlterISchemaRequest(const AlterISchemaRequest& other1541) { + name = other1541.name; + newSchema = other1541.newSchema; + __isset = other1541.__isset; +} +AlterISchemaRequest& AlterISchemaRequest::operator=(const AlterISchemaRequest& other1542) { + name = other1542.name; + newSchema = other1542.newSchema; + __isset = other1542.__isset; + return *this; +} +void AlterISchemaRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AlterISchemaRequest("; + out << "name=" << to_string(name); + out << ", " << "newSchema=" << to_string(newSchema); + out << ")"; +} + + +SchemaVersion::~SchemaVersion() noexcept { +} + +SchemaVersion::SchemaVersion() noexcept + : version(0), + createdAt(0), + state(static_cast(0)), + description(), + schemaText(), + fingerprint(), + name() { +} + +void SchemaVersion::__set_schema(const ISchemaName& val) { + this->schema = val; +} + +void SchemaVersion::__set_version(const int32_t val) { + this->version = val; +} + +void SchemaVersion::__set_createdAt(const int64_t val) { + this->createdAt = val; +} + +void SchemaVersion::__set_cols(const std::vector & val) { + this->cols = val; +} + +void SchemaVersion::__set_state(const SchemaVersionState::type val) { + this->state = val; +__isset.state = true; +} + +void SchemaVersion::__set_description(const std::string& val) { + this->description = val; +__isset.description = true; +} + +void SchemaVersion::__set_schemaText(const std::string& val) { + this->schemaText = val; +__isset.schemaText = true; +} + +void SchemaVersion::__set_fingerprint(const std::string& val) { + this->fingerprint = val; +__isset.fingerprint = true; +} + +void SchemaVersion::__set_name(const std::string& val) { + this->name = val; +__isset.name = true; +} + +void SchemaVersion::__set_serDe(const SerDeInfo& val) { + this->serDe = val; +__isset.serDe = true; +} +std::ostream& operator<<(std::ostream& out, const SchemaVersion& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t SchemaVersion::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->schema.read(iprot); + this->__isset.schema = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->version); + this->__isset.version = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->createdAt); + this->__isset.createdAt = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->cols.clear(); + uint32_t _size1543; + ::apache::thrift::protocol::TType _etype1546; + xfer += iprot->readListBegin(_etype1546, _size1543); + this->cols.resize(_size1543); + uint32_t _i1547; + for (_i1547 = 0; _i1547 < _size1543; ++_i1547) + { + xfer += this->cols[_i1547].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.cols = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1548; + xfer += iprot->readI32(ecast1548); + this->state = static_cast(ecast1548); + this->__isset.state = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->description); + this->__isset.description = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->schemaText); + this->__isset.schemaText = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->fingerprint); + this->__isset.fingerprint = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->serDe.read(iprot); + this->__isset.serDe = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t SchemaVersion::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("SchemaVersion"); + + xfer += oprot->writeFieldBegin("schema", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->schema.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("version", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(this->version); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("createdAt", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->createdAt); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("cols", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->cols.size())); + std::vector ::const_iterator _iter1549; + for (_iter1549 = this->cols.begin(); _iter1549 != this->cols.end(); ++_iter1549) + { + xfer += (*_iter1549).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.state) { + xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_I32, 5); + xfer += oprot->writeI32(static_cast(this->state)); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.description) { + xfer += oprot->writeFieldBegin("description", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->description); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.schemaText) { + xfer += oprot->writeFieldBegin("schemaText", ::apache::thrift::protocol::T_STRING, 7); + xfer += oprot->writeString(this->schemaText); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.fingerprint) { + xfer += oprot->writeFieldBegin("fingerprint", ::apache::thrift::protocol::T_STRING, 8); + xfer += oprot->writeString(this->fingerprint); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.name) { + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 9); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.serDe) { + xfer += oprot->writeFieldBegin("serDe", ::apache::thrift::protocol::T_STRUCT, 10); + xfer += this->serDe.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(SchemaVersion &a, SchemaVersion &b) noexcept { + using ::std::swap; + swap(a.schema, b.schema); + swap(a.version, b.version); + swap(a.createdAt, b.createdAt); + swap(a.cols, b.cols); + swap(a.state, b.state); + swap(a.description, b.description); + swap(a.schemaText, b.schemaText); + swap(a.fingerprint, b.fingerprint); + swap(a.name, b.name); + swap(a.serDe, b.serDe); + swap(a.__isset, b.__isset); +} + +bool SchemaVersion::operator==(const SchemaVersion & rhs) const +{ + if (!(schema == rhs.schema)) + return false; + if (!(version == rhs.version)) + return false; + if (!(createdAt == rhs.createdAt)) + return false; + if (!(cols == rhs.cols)) + return false; + if (__isset.state != rhs.__isset.state) + return false; + else if (__isset.state && !(state == rhs.state)) + return false; + if (__isset.description != rhs.__isset.description) + return false; + else if (__isset.description && !(description == rhs.description)) + return false; + if (__isset.schemaText != rhs.__isset.schemaText) + return false; + else if (__isset.schemaText && !(schemaText == rhs.schemaText)) + return false; + if (__isset.fingerprint != rhs.__isset.fingerprint) + return false; + else if (__isset.fingerprint && !(fingerprint == rhs.fingerprint)) + return false; + if (__isset.name != rhs.__isset.name) + return false; + else if (__isset.name && !(name == rhs.name)) + return false; + if (__isset.serDe != rhs.__isset.serDe) + return false; + else if (__isset.serDe && !(serDe == rhs.serDe)) + return false; + return true; +} + +SchemaVersion::SchemaVersion(const SchemaVersion& other1550) { + schema = other1550.schema; + version = other1550.version; + createdAt = other1550.createdAt; + cols = other1550.cols; + state = other1550.state; + description = other1550.description; + schemaText = other1550.schemaText; + fingerprint = other1550.fingerprint; + name = other1550.name; + serDe = other1550.serDe; + __isset = other1550.__isset; +} +SchemaVersion& SchemaVersion::operator=(const SchemaVersion& other1551) { + schema = other1551.schema; + version = other1551.version; + createdAt = other1551.createdAt; + cols = other1551.cols; + state = other1551.state; + description = other1551.description; + schemaText = other1551.schemaText; + fingerprint = other1551.fingerprint; + name = other1551.name; + serDe = other1551.serDe; + __isset = other1551.__isset; + return *this; +} +void SchemaVersion::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "SchemaVersion("; + out << "schema=" << to_string(schema); + out << ", " << "version=" << to_string(version); + out << ", " << "createdAt=" << to_string(createdAt); + out << ", " << "cols=" << to_string(cols); + out << ", " << "state="; (__isset.state ? (out << to_string(state)) : (out << "")); + out << ", " << "description="; (__isset.description ? (out << to_string(description)) : (out << "")); + out << ", " << "schemaText="; (__isset.schemaText ? (out << to_string(schemaText)) : (out << "")); + out << ", " << "fingerprint="; (__isset.fingerprint ? (out << to_string(fingerprint)) : (out << "")); + out << ", " << "name="; (__isset.name ? (out << to_string(name)) : (out << "")); + out << ", " << "serDe="; (__isset.serDe ? (out << to_string(serDe)) : (out << "")); + out << ")"; +} + + +SchemaVersionDescriptor::~SchemaVersionDescriptor() noexcept { +} + +SchemaVersionDescriptor::SchemaVersionDescriptor() noexcept + : version(0) { +} + +void SchemaVersionDescriptor::__set_schema(const ISchemaName& val) { + this->schema = val; +} + +void SchemaVersionDescriptor::__set_version(const int32_t val) { + this->version = val; +} +std::ostream& operator<<(std::ostream& out, const SchemaVersionDescriptor& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t SchemaVersionDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->schema.read(iprot); + this->__isset.schema = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->version); + this->__isset.version = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t SchemaVersionDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("SchemaVersionDescriptor"); + + xfer += oprot->writeFieldBegin("schema", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->schema.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("version", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(this->version); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(SchemaVersionDescriptor &a, SchemaVersionDescriptor &b) noexcept { + using ::std::swap; + swap(a.schema, b.schema); + swap(a.version, b.version); + swap(a.__isset, b.__isset); +} + +bool SchemaVersionDescriptor::operator==(const SchemaVersionDescriptor & rhs) const +{ + if (!(schema == rhs.schema)) + return false; + if (!(version == rhs.version)) + return false; + return true; +} + +SchemaVersionDescriptor::SchemaVersionDescriptor(const SchemaVersionDescriptor& other1552) { + schema = other1552.schema; + version = other1552.version; + __isset = other1552.__isset; +} +SchemaVersionDescriptor& SchemaVersionDescriptor::operator=(const SchemaVersionDescriptor& other1553) { + schema = other1553.schema; + version = other1553.version; + __isset = other1553.__isset; + return *this; +} +void SchemaVersionDescriptor::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "SchemaVersionDescriptor("; + out << "schema=" << to_string(schema); + out << ", " << "version=" << to_string(version); + out << ")"; +} + + +FindSchemasByColsRqst::~FindSchemasByColsRqst() noexcept { +} + +FindSchemasByColsRqst::FindSchemasByColsRqst() noexcept + : colName(), + colNamespace(), + type() { +} + +void FindSchemasByColsRqst::__set_colName(const std::string& val) { + this->colName = val; +__isset.colName = true; +} + +void FindSchemasByColsRqst::__set_colNamespace(const std::string& val) { + this->colNamespace = val; +__isset.colNamespace = true; +} + +void FindSchemasByColsRqst::__set_type(const std::string& val) { + this->type = val; +__isset.type = true; +} +std::ostream& operator<<(std::ostream& out, const FindSchemasByColsRqst& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t FindSchemasByColsRqst::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->colName); + this->__isset.colName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->colNamespace); + this->__isset.colNamespace = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->type); + this->__isset.type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FindSchemasByColsRqst::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FindSchemasByColsRqst"); + + if (this->__isset.colName) { + xfer += oprot->writeFieldBegin("colName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->colName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.colNamespace) { + xfer += oprot->writeFieldBegin("colNamespace", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->colNamespace); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.type) { + xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->type); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(FindSchemasByColsRqst &a, FindSchemasByColsRqst &b) noexcept { + using ::std::swap; + swap(a.colName, b.colName); + swap(a.colNamespace, b.colNamespace); + swap(a.type, b.type); + swap(a.__isset, b.__isset); +} + +bool FindSchemasByColsRqst::operator==(const FindSchemasByColsRqst & rhs) const +{ + if (__isset.colName != rhs.__isset.colName) + return false; + else if (__isset.colName && !(colName == rhs.colName)) + return false; + if (__isset.colNamespace != rhs.__isset.colNamespace) + return false; + else if (__isset.colNamespace && !(colNamespace == rhs.colNamespace)) + return false; + if (__isset.type != rhs.__isset.type) + return false; + else if (__isset.type && !(type == rhs.type)) + return false; + return true; +} + +FindSchemasByColsRqst::FindSchemasByColsRqst(const FindSchemasByColsRqst& other1554) { + colName = other1554.colName; + colNamespace = other1554.colNamespace; + type = other1554.type; + __isset = other1554.__isset; +} +FindSchemasByColsRqst& FindSchemasByColsRqst::operator=(const FindSchemasByColsRqst& other1555) { + colName = other1555.colName; + colNamespace = other1555.colNamespace; + type = other1555.type; + __isset = other1555.__isset; + return *this; +} +void FindSchemasByColsRqst::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "FindSchemasByColsRqst("; + out << "colName="; (__isset.colName ? (out << to_string(colName)) : (out << "")); + out << ", " << "colNamespace="; (__isset.colNamespace ? (out << to_string(colNamespace)) : (out << "")); + out << ", " << "type="; (__isset.type ? (out << to_string(type)) : (out << "")); + out << ")"; +} + + +FindSchemasByColsResp::~FindSchemasByColsResp() noexcept { +} + +FindSchemasByColsResp::FindSchemasByColsResp() noexcept { +} + +void FindSchemasByColsResp::__set_schemaVersions(const std::vector & val) { + this->schemaVersions = val; +} +std::ostream& operator<<(std::ostream& out, const FindSchemasByColsResp& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t FindSchemasByColsResp::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->schemaVersions.clear(); + uint32_t _size1556; + ::apache::thrift::protocol::TType _etype1559; + xfer += iprot->readListBegin(_etype1559, _size1556); + this->schemaVersions.resize(_size1556); + uint32_t _i1560; + for (_i1560 = 0; _i1560 < _size1556; ++_i1560) + { + xfer += this->schemaVersions[_i1560].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.schemaVersions = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t FindSchemasByColsResp::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("FindSchemasByColsResp"); + + xfer += oprot->writeFieldBegin("schemaVersions", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->schemaVersions.size())); + std::vector ::const_iterator _iter1561; + for (_iter1561 = this->schemaVersions.begin(); _iter1561 != this->schemaVersions.end(); ++_iter1561) + { + xfer += (*_iter1561).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(FindSchemasByColsResp &a, FindSchemasByColsResp &b) noexcept { + using ::std::swap; + swap(a.schemaVersions, b.schemaVersions); + swap(a.__isset, b.__isset); +} + +bool FindSchemasByColsResp::operator==(const FindSchemasByColsResp & rhs) const +{ + if (!(schemaVersions == rhs.schemaVersions)) + return false; + return true; +} + +FindSchemasByColsResp::FindSchemasByColsResp(const FindSchemasByColsResp& other1562) { + schemaVersions = other1562.schemaVersions; + __isset = other1562.__isset; +} +FindSchemasByColsResp& FindSchemasByColsResp::operator=(const FindSchemasByColsResp& other1563) { + schemaVersions = other1563.schemaVersions; + __isset = other1563.__isset; + return *this; +} +void FindSchemasByColsResp::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "FindSchemasByColsResp("; + out << "schemaVersions=" << to_string(schemaVersions); + out << ")"; +} + + +MapSchemaVersionToSerdeRequest::~MapSchemaVersionToSerdeRequest() noexcept { +} + +MapSchemaVersionToSerdeRequest::MapSchemaVersionToSerdeRequest() noexcept + : serdeName() { +} + +void MapSchemaVersionToSerdeRequest::__set_schemaVersion(const SchemaVersionDescriptor& val) { + this->schemaVersion = val; +} + +void MapSchemaVersionToSerdeRequest::__set_serdeName(const std::string& val) { + this->serdeName = val; +} +std::ostream& operator<<(std::ostream& out, const MapSchemaVersionToSerdeRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t MapSchemaVersionToSerdeRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->schemaVersion.read(iprot); + this->__isset.schemaVersion = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->serdeName); + this->__isset.serdeName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t MapSchemaVersionToSerdeRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("MapSchemaVersionToSerdeRequest"); + + xfer += oprot->writeFieldBegin("schemaVersion", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->schemaVersion.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("serdeName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->serdeName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(MapSchemaVersionToSerdeRequest &a, MapSchemaVersionToSerdeRequest &b) noexcept { + using ::std::swap; + swap(a.schemaVersion, b.schemaVersion); + swap(a.serdeName, b.serdeName); + swap(a.__isset, b.__isset); +} + +bool MapSchemaVersionToSerdeRequest::operator==(const MapSchemaVersionToSerdeRequest & rhs) const +{ + if (!(schemaVersion == rhs.schemaVersion)) + return false; + if (!(serdeName == rhs.serdeName)) + return false; + return true; +} + +MapSchemaVersionToSerdeRequest::MapSchemaVersionToSerdeRequest(const MapSchemaVersionToSerdeRequest& other1564) { + schemaVersion = other1564.schemaVersion; + serdeName = other1564.serdeName; + __isset = other1564.__isset; +} +MapSchemaVersionToSerdeRequest& MapSchemaVersionToSerdeRequest::operator=(const MapSchemaVersionToSerdeRequest& other1565) { + schemaVersion = other1565.schemaVersion; + serdeName = other1565.serdeName; + __isset = other1565.__isset; + return *this; +} +void MapSchemaVersionToSerdeRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "MapSchemaVersionToSerdeRequest("; + out << "schemaVersion=" << to_string(schemaVersion); + out << ", " << "serdeName=" << to_string(serdeName); + out << ")"; +} + + +SetSchemaVersionStateRequest::~SetSchemaVersionStateRequest() noexcept { +} + +SetSchemaVersionStateRequest::SetSchemaVersionStateRequest() noexcept + : state(static_cast(0)) { +} + +void SetSchemaVersionStateRequest::__set_schemaVersion(const SchemaVersionDescriptor& val) { + this->schemaVersion = val; +} + +void SetSchemaVersionStateRequest::__set_state(const SchemaVersionState::type val) { + this->state = val; +} +std::ostream& operator<<(std::ostream& out, const SetSchemaVersionStateRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t SetSchemaVersionStateRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->schemaVersion.read(iprot); + this->__isset.schemaVersion = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1566; + xfer += iprot->readI32(ecast1566); + this->state = static_cast(ecast1566); + this->__isset.state = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t SetSchemaVersionStateRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("SetSchemaVersionStateRequest"); + + xfer += oprot->writeFieldBegin("schemaVersion", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->schemaVersion.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(static_cast(this->state)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(SetSchemaVersionStateRequest &a, SetSchemaVersionStateRequest &b) noexcept { + using ::std::swap; + swap(a.schemaVersion, b.schemaVersion); + swap(a.state, b.state); + swap(a.__isset, b.__isset); +} + +bool SetSchemaVersionStateRequest::operator==(const SetSchemaVersionStateRequest & rhs) const +{ + if (!(schemaVersion == rhs.schemaVersion)) + return false; + if (!(state == rhs.state)) + return false; + return true; +} + +SetSchemaVersionStateRequest::SetSchemaVersionStateRequest(const SetSchemaVersionStateRequest& other1567) { + schemaVersion = other1567.schemaVersion; + state = other1567.state; + __isset = other1567.__isset; +} +SetSchemaVersionStateRequest& SetSchemaVersionStateRequest::operator=(const SetSchemaVersionStateRequest& other1568) { + schemaVersion = other1568.schemaVersion; + state = other1568.state; + __isset = other1568.__isset; + return *this; +} +void SetSchemaVersionStateRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "SetSchemaVersionStateRequest("; + out << "schemaVersion=" << to_string(schemaVersion); + out << ", " << "state=" << to_string(state); + out << ")"; +} + + +GetSerdeRequest::~GetSerdeRequest() noexcept { +} + +GetSerdeRequest::GetSerdeRequest() noexcept + : serdeName() { +} + +void GetSerdeRequest::__set_serdeName(const std::string& val) { + this->serdeName = val; +} +std::ostream& operator<<(std::ostream& out, const GetSerdeRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetSerdeRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->serdeName); + this->__isset.serdeName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t GetSerdeRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetSerdeRequest"); + + xfer += oprot->writeFieldBegin("serdeName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->serdeName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetSerdeRequest &a, GetSerdeRequest &b) noexcept { + using ::std::swap; + swap(a.serdeName, b.serdeName); + swap(a.__isset, b.__isset); +} + +bool GetSerdeRequest::operator==(const GetSerdeRequest & rhs) const +{ + if (!(serdeName == rhs.serdeName)) + return false; + return true; +} + +GetSerdeRequest::GetSerdeRequest(const GetSerdeRequest& other1569) { + serdeName = other1569.serdeName; + __isset = other1569.__isset; +} +GetSerdeRequest& GetSerdeRequest::operator=(const GetSerdeRequest& other1570) { + serdeName = other1570.serdeName; + __isset = other1570.__isset; + return *this; +} +void GetSerdeRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetSerdeRequest("; + out << "serdeName=" << to_string(serdeName); + out << ")"; +} + + +RuntimeStat::~RuntimeStat() noexcept { +} + +RuntimeStat::RuntimeStat() noexcept + : createTime(0), + weight(0), + payload() { +} + +void RuntimeStat::__set_createTime(const int32_t val) { + this->createTime = val; +__isset.createTime = true; +} + +void RuntimeStat::__set_weight(const int32_t val) { + this->weight = val; +} + +void RuntimeStat::__set_payload(const std::string& val) { + this->payload = val; +} +std::ostream& operator<<(std::ostream& out, const RuntimeStat& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t RuntimeStat::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_weight = false; + bool isset_payload = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->createTime); + this->__isset.createTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->weight); + isset_weight = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->payload); + isset_payload = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_weight) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_payload) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t RuntimeStat::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("RuntimeStat"); + + if (this->__isset.createTime) { + xfer += oprot->writeFieldBegin("createTime", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32(this->createTime); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("weight", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(this->weight); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("payload", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeBinary(this->payload); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(RuntimeStat &a, RuntimeStat &b) noexcept { + using ::std::swap; + swap(a.createTime, b.createTime); + swap(a.weight, b.weight); + swap(a.payload, b.payload); + swap(a.__isset, b.__isset); +} + +bool RuntimeStat::operator==(const RuntimeStat & rhs) const +{ + if (__isset.createTime != rhs.__isset.createTime) + return false; + else if (__isset.createTime && !(createTime == rhs.createTime)) + return false; + if (!(weight == rhs.weight)) + return false; + if (!(payload == rhs.payload)) + return false; + return true; +} + +RuntimeStat::RuntimeStat(const RuntimeStat& other1571) { + createTime = other1571.createTime; + weight = other1571.weight; + payload = other1571.payload; + __isset = other1571.__isset; +} +RuntimeStat& RuntimeStat::operator=(const RuntimeStat& other1572) { + createTime = other1572.createTime; + weight = other1572.weight; + payload = other1572.payload; + __isset = other1572.__isset; + return *this; +} +void RuntimeStat::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "RuntimeStat("; + out << "createTime="; (__isset.createTime ? (out << to_string(createTime)) : (out << "")); + out << ", " << "weight=" << to_string(weight); + out << ", " << "payload=" << to_string(payload); + out << ")"; +} + + +GetRuntimeStatsRequest::~GetRuntimeStatsRequest() noexcept { +} + +GetRuntimeStatsRequest::GetRuntimeStatsRequest() noexcept + : maxWeight(0), + maxCreateTime(0) { +} + +void GetRuntimeStatsRequest::__set_maxWeight(const int32_t val) { + this->maxWeight = val; +} + +void GetRuntimeStatsRequest::__set_maxCreateTime(const int32_t val) { + this->maxCreateTime = val; +} +std::ostream& operator<<(std::ostream& out, const GetRuntimeStatsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetRuntimeStatsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_maxWeight = false; + bool isset_maxCreateTime = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->maxWeight); + isset_maxWeight = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->maxCreateTime); + isset_maxCreateTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_maxWeight) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_maxCreateTime) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetRuntimeStatsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetRuntimeStatsRequest"); + + xfer += oprot->writeFieldBegin("maxWeight", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32(this->maxWeight); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("maxCreateTime", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(this->maxCreateTime); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetRuntimeStatsRequest &a, GetRuntimeStatsRequest &b) noexcept { + using ::std::swap; + swap(a.maxWeight, b.maxWeight); + swap(a.maxCreateTime, b.maxCreateTime); +} + +bool GetRuntimeStatsRequest::operator==(const GetRuntimeStatsRequest & rhs) const +{ + if (!(maxWeight == rhs.maxWeight)) + return false; + if (!(maxCreateTime == rhs.maxCreateTime)) + return false; + return true; +} + +GetRuntimeStatsRequest::GetRuntimeStatsRequest(const GetRuntimeStatsRequest& other1573) noexcept { + maxWeight = other1573.maxWeight; + maxCreateTime = other1573.maxCreateTime; +} +GetRuntimeStatsRequest& GetRuntimeStatsRequest::operator=(const GetRuntimeStatsRequest& other1574) noexcept { + maxWeight = other1574.maxWeight; + maxCreateTime = other1574.maxCreateTime; + return *this; +} +void GetRuntimeStatsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetRuntimeStatsRequest("; + out << "maxWeight=" << to_string(maxWeight); + out << ", " << "maxCreateTime=" << to_string(maxCreateTime); + out << ")"; +} + + +CreateTableRequest::~CreateTableRequest() noexcept { +} + +CreateTableRequest::CreateTableRequest() noexcept + : processorIdentifier() { +} + +void CreateTableRequest::__set_table(const Table& val) { + this->table = val; +} + +void CreateTableRequest::__set_envContext(const EnvironmentContext& val) { + this->envContext = val; +__isset.envContext = true; +} + +void CreateTableRequest::__set_primaryKeys(const std::vector & val) { + this->primaryKeys = val; +__isset.primaryKeys = true; +} + +void CreateTableRequest::__set_foreignKeys(const std::vector & val) { + this->foreignKeys = val; +__isset.foreignKeys = true; +} + +void CreateTableRequest::__set_uniqueConstraints(const std::vector & val) { + this->uniqueConstraints = val; +__isset.uniqueConstraints = true; +} + +void CreateTableRequest::__set_notNullConstraints(const std::vector & val) { + this->notNullConstraints = val; +__isset.notNullConstraints = true; +} + +void CreateTableRequest::__set_defaultConstraints(const std::vector & val) { + this->defaultConstraints = val; +__isset.defaultConstraints = true; +} + +void CreateTableRequest::__set_checkConstraints(const std::vector & val) { + this->checkConstraints = val; +__isset.checkConstraints = true; +} + +void CreateTableRequest::__set_processorCapabilities(const std::vector & val) { + this->processorCapabilities = val; +__isset.processorCapabilities = true; +} + +void CreateTableRequest::__set_processorIdentifier(const std::string& val) { + this->processorIdentifier = val; +__isset.processorIdentifier = true; +} +std::ostream& operator<<(std::ostream& out, const CreateTableRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t CreateTableRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_table = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->table.read(iprot); + isset_table = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->envContext.read(iprot); + this->__isset.envContext = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->primaryKeys.clear(); + uint32_t _size1575; + ::apache::thrift::protocol::TType _etype1578; + xfer += iprot->readListBegin(_etype1578, _size1575); + this->primaryKeys.resize(_size1575); + uint32_t _i1579; + for (_i1579 = 0; _i1579 < _size1575; ++_i1579) + { + xfer += this->primaryKeys[_i1579].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.primaryKeys = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->foreignKeys.clear(); + uint32_t _size1580; + ::apache::thrift::protocol::TType _etype1583; + xfer += iprot->readListBegin(_etype1583, _size1580); + this->foreignKeys.resize(_size1580); + uint32_t _i1584; + for (_i1584 = 0; _i1584 < _size1580; ++_i1584) + { + xfer += this->foreignKeys[_i1584].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.foreignKeys = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->uniqueConstraints.clear(); + uint32_t _size1585; + ::apache::thrift::protocol::TType _etype1588; + xfer += iprot->readListBegin(_etype1588, _size1585); + this->uniqueConstraints.resize(_size1585); + uint32_t _i1589; + for (_i1589 = 0; _i1589 < _size1585; ++_i1589) + { + xfer += this->uniqueConstraints[_i1589].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.uniqueConstraints = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->notNullConstraints.clear(); + uint32_t _size1590; + ::apache::thrift::protocol::TType _etype1593; + xfer += iprot->readListBegin(_etype1593, _size1590); + this->notNullConstraints.resize(_size1590); + uint32_t _i1594; + for (_i1594 = 0; _i1594 < _size1590; ++_i1594) + { + xfer += this->notNullConstraints[_i1594].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.notNullConstraints = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->defaultConstraints.clear(); + uint32_t _size1595; + ::apache::thrift::protocol::TType _etype1598; + xfer += iprot->readListBegin(_etype1598, _size1595); + this->defaultConstraints.resize(_size1595); + uint32_t _i1599; + for (_i1599 = 0; _i1599 < _size1595; ++_i1599) + { + xfer += this->defaultConstraints[_i1599].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.defaultConstraints = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->checkConstraints.clear(); + uint32_t _size1600; + ::apache::thrift::protocol::TType _etype1603; + xfer += iprot->readListBegin(_etype1603, _size1600); + this->checkConstraints.resize(_size1600); + uint32_t _i1604; + for (_i1604 = 0; _i1604 < _size1600; ++_i1604) + { + xfer += this->checkConstraints[_i1604].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.checkConstraints = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->processorCapabilities.clear(); + uint32_t _size1605; + ::apache::thrift::protocol::TType _etype1608; + xfer += iprot->readListBegin(_etype1608, _size1605); + this->processorCapabilities.resize(_size1605); + uint32_t _i1609; + for (_i1609 = 0; _i1609 < _size1605; ++_i1609) + { + xfer += iprot->readString(this->processorCapabilities[_i1609]); + } + xfer += iprot->readListEnd(); + } + this->__isset.processorCapabilities = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->processorIdentifier); + this->__isset.processorIdentifier = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_table) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t CreateTableRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CreateTableRequest"); + + xfer += oprot->writeFieldBegin("table", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->table.write(oprot); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.envContext) { + xfer += oprot->writeFieldBegin("envContext", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->envContext.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.primaryKeys) { + xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->primaryKeys.size())); + std::vector ::const_iterator _iter1610; + for (_iter1610 = this->primaryKeys.begin(); _iter1610 != this->primaryKeys.end(); ++_iter1610) + { + xfer += (*_iter1610).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.foreignKeys) { + xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->foreignKeys.size())); + std::vector ::const_iterator _iter1611; + for (_iter1611 = this->foreignKeys.begin(); _iter1611 != this->foreignKeys.end(); ++_iter1611) + { + xfer += (*_iter1611).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.uniqueConstraints) { + xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 5); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->uniqueConstraints.size())); + std::vector ::const_iterator _iter1612; + for (_iter1612 = this->uniqueConstraints.begin(); _iter1612 != this->uniqueConstraints.end(); ++_iter1612) + { + xfer += (*_iter1612).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.notNullConstraints) { + xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 6); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->notNullConstraints.size())); + std::vector ::const_iterator _iter1613; + for (_iter1613 = this->notNullConstraints.begin(); _iter1613 != this->notNullConstraints.end(); ++_iter1613) + { + xfer += (*_iter1613).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.defaultConstraints) { + xfer += oprot->writeFieldBegin("defaultConstraints", ::apache::thrift::protocol::T_LIST, 7); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->defaultConstraints.size())); + std::vector ::const_iterator _iter1614; + for (_iter1614 = this->defaultConstraints.begin(); _iter1614 != this->defaultConstraints.end(); ++_iter1614) + { + xfer += (*_iter1614).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.checkConstraints) { + xfer += oprot->writeFieldBegin("checkConstraints", ::apache::thrift::protocol::T_LIST, 8); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->checkConstraints.size())); + std::vector ::const_iterator _iter1615; + for (_iter1615 = this->checkConstraints.begin(); _iter1615 != this->checkConstraints.end(); ++_iter1615) + { + xfer += (*_iter1615).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.processorCapabilities) { + xfer += oprot->writeFieldBegin("processorCapabilities", ::apache::thrift::protocol::T_LIST, 9); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->processorCapabilities.size())); + std::vector ::const_iterator _iter1616; + for (_iter1616 = this->processorCapabilities.begin(); _iter1616 != this->processorCapabilities.end(); ++_iter1616) + { + xfer += oprot->writeString((*_iter1616)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.processorIdentifier) { + xfer += oprot->writeFieldBegin("processorIdentifier", ::apache::thrift::protocol::T_STRING, 10); + xfer += oprot->writeString(this->processorIdentifier); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CreateTableRequest &a, CreateTableRequest &b) noexcept { + using ::std::swap; + swap(a.table, b.table); + swap(a.envContext, b.envContext); + swap(a.primaryKeys, b.primaryKeys); + swap(a.foreignKeys, b.foreignKeys); + swap(a.uniqueConstraints, b.uniqueConstraints); + swap(a.notNullConstraints, b.notNullConstraints); + swap(a.defaultConstraints, b.defaultConstraints); + swap(a.checkConstraints, b.checkConstraints); + swap(a.processorCapabilities, b.processorCapabilities); + swap(a.processorIdentifier, b.processorIdentifier); + swap(a.__isset, b.__isset); +} + +bool CreateTableRequest::operator==(const CreateTableRequest & rhs) const +{ + if (!(table == rhs.table)) + return false; + if (__isset.envContext != rhs.__isset.envContext) + return false; + else if (__isset.envContext && !(envContext == rhs.envContext)) + return false; + if (__isset.primaryKeys != rhs.__isset.primaryKeys) + return false; + else if (__isset.primaryKeys && !(primaryKeys == rhs.primaryKeys)) + return false; + if (__isset.foreignKeys != rhs.__isset.foreignKeys) + return false; + else if (__isset.foreignKeys && !(foreignKeys == rhs.foreignKeys)) + return false; + if (__isset.uniqueConstraints != rhs.__isset.uniqueConstraints) + return false; + else if (__isset.uniqueConstraints && !(uniqueConstraints == rhs.uniqueConstraints)) + return false; + if (__isset.notNullConstraints != rhs.__isset.notNullConstraints) + return false; + else if (__isset.notNullConstraints && !(notNullConstraints == rhs.notNullConstraints)) + return false; + if (__isset.defaultConstraints != rhs.__isset.defaultConstraints) + return false; + else if (__isset.defaultConstraints && !(defaultConstraints == rhs.defaultConstraints)) + return false; + if (__isset.checkConstraints != rhs.__isset.checkConstraints) + return false; + else if (__isset.checkConstraints && !(checkConstraints == rhs.checkConstraints)) + return false; + if (__isset.processorCapabilities != rhs.__isset.processorCapabilities) + return false; + else if (__isset.processorCapabilities && !(processorCapabilities == rhs.processorCapabilities)) + return false; + if (__isset.processorIdentifier != rhs.__isset.processorIdentifier) + return false; + else if (__isset.processorIdentifier && !(processorIdentifier == rhs.processorIdentifier)) + return false; + return true; +} + +CreateTableRequest::CreateTableRequest(const CreateTableRequest& other1617) { + table = other1617.table; + envContext = other1617.envContext; + primaryKeys = other1617.primaryKeys; + foreignKeys = other1617.foreignKeys; + uniqueConstraints = other1617.uniqueConstraints; + notNullConstraints = other1617.notNullConstraints; + defaultConstraints = other1617.defaultConstraints; + checkConstraints = other1617.checkConstraints; + processorCapabilities = other1617.processorCapabilities; + processorIdentifier = other1617.processorIdentifier; + __isset = other1617.__isset; +} +CreateTableRequest& CreateTableRequest::operator=(const CreateTableRequest& other1618) { + table = other1618.table; + envContext = other1618.envContext; + primaryKeys = other1618.primaryKeys; + foreignKeys = other1618.foreignKeys; + uniqueConstraints = other1618.uniqueConstraints; + notNullConstraints = other1618.notNullConstraints; + defaultConstraints = other1618.defaultConstraints; + checkConstraints = other1618.checkConstraints; + processorCapabilities = other1618.processorCapabilities; + processorIdentifier = other1618.processorIdentifier; + __isset = other1618.__isset; + return *this; +} +void CreateTableRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CreateTableRequest("; + out << "table=" << to_string(table); + out << ", " << "envContext="; (__isset.envContext ? (out << to_string(envContext)) : (out << "")); + out << ", " << "primaryKeys="; (__isset.primaryKeys ? (out << to_string(primaryKeys)) : (out << "")); + out << ", " << "foreignKeys="; (__isset.foreignKeys ? (out << to_string(foreignKeys)) : (out << "")); + out << ", " << "uniqueConstraints="; (__isset.uniqueConstraints ? (out << to_string(uniqueConstraints)) : (out << "")); + out << ", " << "notNullConstraints="; (__isset.notNullConstraints ? (out << to_string(notNullConstraints)) : (out << "")); + out << ", " << "defaultConstraints="; (__isset.defaultConstraints ? (out << to_string(defaultConstraints)) : (out << "")); + out << ", " << "checkConstraints="; (__isset.checkConstraints ? (out << to_string(checkConstraints)) : (out << "")); + out << ", " << "processorCapabilities="; (__isset.processorCapabilities ? (out << to_string(processorCapabilities)) : (out << "")); + out << ", " << "processorIdentifier="; (__isset.processorIdentifier ? (out << to_string(processorIdentifier)) : (out << "")); + out << ")"; +} + + +CreateDatabaseRequest::~CreateDatabaseRequest() noexcept { +} + +CreateDatabaseRequest::CreateDatabaseRequest() noexcept + : databaseName(), + description(), + locationUri(), + ownerName(), + ownerType(static_cast(0)), + catalogName(), + createTime(0), + managedLocationUri(), + type(static_cast(0)), + dataConnectorName(), + remote_dbname() { +} + +void CreateDatabaseRequest::__set_databaseName(const std::string& val) { + this->databaseName = val; +} + +void CreateDatabaseRequest::__set_description(const std::string& val) { + this->description = val; +__isset.description = true; +} + +void CreateDatabaseRequest::__set_locationUri(const std::string& val) { + this->locationUri = val; +__isset.locationUri = true; +} + +void CreateDatabaseRequest::__set_parameters(const std::map & val) { + this->parameters = val; +__isset.parameters = true; +} + +void CreateDatabaseRequest::__set_privileges(const PrincipalPrivilegeSet& val) { + this->privileges = val; +__isset.privileges = true; +} + +void CreateDatabaseRequest::__set_ownerName(const std::string& val) { + this->ownerName = val; +__isset.ownerName = true; +} + +void CreateDatabaseRequest::__set_ownerType(const PrincipalType::type val) { + this->ownerType = val; +__isset.ownerType = true; +} + +void CreateDatabaseRequest::__set_catalogName(const std::string& val) { + this->catalogName = val; +__isset.catalogName = true; +} + +void CreateDatabaseRequest::__set_createTime(const int32_t val) { + this->createTime = val; +__isset.createTime = true; +} + +void CreateDatabaseRequest::__set_managedLocationUri(const std::string& val) { + this->managedLocationUri = val; +__isset.managedLocationUri = true; +} + +void CreateDatabaseRequest::__set_type(const DatabaseType::type val) { + this->type = val; +__isset.type = true; +} + +void CreateDatabaseRequest::__set_dataConnectorName(const std::string& val) { + this->dataConnectorName = val; +__isset.dataConnectorName = true; +} + +void CreateDatabaseRequest::__set_remote_dbname(const std::string& val) { + this->remote_dbname = val; +__isset.remote_dbname = true; +} +std::ostream& operator<<(std::ostream& out, const CreateDatabaseRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t CreateDatabaseRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_databaseName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->databaseName); + isset_databaseName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->description); + this->__isset.description = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->locationUri); + this->__isset.locationUri = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->parameters.clear(); + uint32_t _size1619; + ::apache::thrift::protocol::TType _ktype1620; + ::apache::thrift::protocol::TType _vtype1621; + xfer += iprot->readMapBegin(_ktype1620, _vtype1621, _size1619); + uint32_t _i1623; + for (_i1623 = 0; _i1623 < _size1619; ++_i1623) + { + std::string _key1624; + xfer += iprot->readString(_key1624); + std::string& _val1625 = this->parameters[_key1624]; + xfer += iprot->readString(_val1625); + } + xfer += iprot->readMapEnd(); + } + this->__isset.parameters = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->privileges.read(iprot); + this->__isset.privileges = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ownerName); + this->__isset.ownerName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1626; + xfer += iprot->readI32(ecast1626); + this->ownerType = static_cast(ecast1626); + this->__isset.ownerType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catalogName); + this->__isset.catalogName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->createTime); + this->__isset.createTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->managedLocationUri); + this->__isset.managedLocationUri = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 11: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1627; + xfer += iprot->readI32(ecast1627); + this->type = static_cast(ecast1627); + this->__isset.type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 12: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dataConnectorName); + this->__isset.dataConnectorName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 13: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->remote_dbname); + this->__isset.remote_dbname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_databaseName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t CreateDatabaseRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CreateDatabaseRequest"); + + xfer += oprot->writeFieldBegin("databaseName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->databaseName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.description) { + xfer += oprot->writeFieldBegin("description", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->description); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.locationUri) { + xfer += oprot->writeFieldBegin("locationUri", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->locationUri); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.parameters) { + xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 4); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); + std::map ::const_iterator _iter1628; + for (_iter1628 = this->parameters.begin(); _iter1628 != this->parameters.end(); ++_iter1628) + { + xfer += oprot->writeString(_iter1628->first); + xfer += oprot->writeString(_iter1628->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.privileges) { + xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_STRUCT, 5); + xfer += this->privileges.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ownerName) { + xfer += oprot->writeFieldBegin("ownerName", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->ownerName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ownerType) { + xfer += oprot->writeFieldBegin("ownerType", ::apache::thrift::protocol::T_I32, 7); + xfer += oprot->writeI32(static_cast(this->ownerType)); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.catalogName) { + xfer += oprot->writeFieldBegin("catalogName", ::apache::thrift::protocol::T_STRING, 8); + xfer += oprot->writeString(this->catalogName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.createTime) { + xfer += oprot->writeFieldBegin("createTime", ::apache::thrift::protocol::T_I32, 9); + xfer += oprot->writeI32(this->createTime); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.managedLocationUri) { + xfer += oprot->writeFieldBegin("managedLocationUri", ::apache::thrift::protocol::T_STRING, 10); + xfer += oprot->writeString(this->managedLocationUri); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.type) { + xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 11); + xfer += oprot->writeI32(static_cast(this->type)); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.dataConnectorName) { + xfer += oprot->writeFieldBegin("dataConnectorName", ::apache::thrift::protocol::T_STRING, 12); + xfer += oprot->writeString(this->dataConnectorName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.remote_dbname) { + xfer += oprot->writeFieldBegin("remote_dbname", ::apache::thrift::protocol::T_STRING, 13); + xfer += oprot->writeString(this->remote_dbname); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CreateDatabaseRequest &a, CreateDatabaseRequest &b) noexcept { + using ::std::swap; + swap(a.databaseName, b.databaseName); + swap(a.description, b.description); + swap(a.locationUri, b.locationUri); + swap(a.parameters, b.parameters); + swap(a.privileges, b.privileges); + swap(a.ownerName, b.ownerName); + swap(a.ownerType, b.ownerType); + swap(a.catalogName, b.catalogName); + swap(a.createTime, b.createTime); + swap(a.managedLocationUri, b.managedLocationUri); + swap(a.type, b.type); + swap(a.dataConnectorName, b.dataConnectorName); + swap(a.remote_dbname, b.remote_dbname); + swap(a.__isset, b.__isset); +} + +bool CreateDatabaseRequest::operator==(const CreateDatabaseRequest & rhs) const +{ + if (!(databaseName == rhs.databaseName)) + return false; + if (__isset.description != rhs.__isset.description) + return false; + else if (__isset.description && !(description == rhs.description)) + return false; + if (__isset.locationUri != rhs.__isset.locationUri) + return false; + else if (__isset.locationUri && !(locationUri == rhs.locationUri)) + return false; + if (__isset.parameters != rhs.__isset.parameters) + return false; + else if (__isset.parameters && !(parameters == rhs.parameters)) + return false; + if (__isset.privileges != rhs.__isset.privileges) + return false; + else if (__isset.privileges && !(privileges == rhs.privileges)) + return false; + if (__isset.ownerName != rhs.__isset.ownerName) + return false; + else if (__isset.ownerName && !(ownerName == rhs.ownerName)) + return false; + if (__isset.ownerType != rhs.__isset.ownerType) + return false; + else if (__isset.ownerType && !(ownerType == rhs.ownerType)) + return false; + if (__isset.catalogName != rhs.__isset.catalogName) + return false; + else if (__isset.catalogName && !(catalogName == rhs.catalogName)) + return false; + if (__isset.createTime != rhs.__isset.createTime) + return false; + else if (__isset.createTime && !(createTime == rhs.createTime)) + return false; + if (__isset.managedLocationUri != rhs.__isset.managedLocationUri) + return false; + else if (__isset.managedLocationUri && !(managedLocationUri == rhs.managedLocationUri)) + return false; + if (__isset.type != rhs.__isset.type) + return false; + else if (__isset.type && !(type == rhs.type)) + return false; + if (__isset.dataConnectorName != rhs.__isset.dataConnectorName) + return false; + else if (__isset.dataConnectorName && !(dataConnectorName == rhs.dataConnectorName)) + return false; + if (__isset.remote_dbname != rhs.__isset.remote_dbname) + return false; + else if (__isset.remote_dbname && !(remote_dbname == rhs.remote_dbname)) + return false; + return true; +} + +CreateDatabaseRequest::CreateDatabaseRequest(const CreateDatabaseRequest& other1629) { + databaseName = other1629.databaseName; + description = other1629.description; + locationUri = other1629.locationUri; + parameters = other1629.parameters; + privileges = other1629.privileges; + ownerName = other1629.ownerName; + ownerType = other1629.ownerType; + catalogName = other1629.catalogName; + createTime = other1629.createTime; + managedLocationUri = other1629.managedLocationUri; + type = other1629.type; + dataConnectorName = other1629.dataConnectorName; + remote_dbname = other1629.remote_dbname; + __isset = other1629.__isset; +} +CreateDatabaseRequest& CreateDatabaseRequest::operator=(const CreateDatabaseRequest& other1630) { + databaseName = other1630.databaseName; + description = other1630.description; + locationUri = other1630.locationUri; + parameters = other1630.parameters; + privileges = other1630.privileges; + ownerName = other1630.ownerName; + ownerType = other1630.ownerType; + catalogName = other1630.catalogName; + createTime = other1630.createTime; + managedLocationUri = other1630.managedLocationUri; + type = other1630.type; + dataConnectorName = other1630.dataConnectorName; + remote_dbname = other1630.remote_dbname; + __isset = other1630.__isset; + return *this; +} +void CreateDatabaseRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CreateDatabaseRequest("; + out << "databaseName=" << to_string(databaseName); + out << ", " << "description="; (__isset.description ? (out << to_string(description)) : (out << "")); + out << ", " << "locationUri="; (__isset.locationUri ? (out << to_string(locationUri)) : (out << "")); + out << ", " << "parameters="; (__isset.parameters ? (out << to_string(parameters)) : (out << "")); + out << ", " << "privileges="; (__isset.privileges ? (out << to_string(privileges)) : (out << "")); + out << ", " << "ownerName="; (__isset.ownerName ? (out << to_string(ownerName)) : (out << "")); + out << ", " << "ownerType="; (__isset.ownerType ? (out << to_string(ownerType)) : (out << "")); + out << ", " << "catalogName="; (__isset.catalogName ? (out << to_string(catalogName)) : (out << "")); + out << ", " << "createTime="; (__isset.createTime ? (out << to_string(createTime)) : (out << "")); + out << ", " << "managedLocationUri="; (__isset.managedLocationUri ? (out << to_string(managedLocationUri)) : (out << "")); + out << ", " << "type="; (__isset.type ? (out << to_string(type)) : (out << "")); + out << ", " << "dataConnectorName="; (__isset.dataConnectorName ? (out << to_string(dataConnectorName)) : (out << "")); + out << ", " << "remote_dbname="; (__isset.remote_dbname ? (out << to_string(remote_dbname)) : (out << "")); + out << ")"; +} + + +CreateDataConnectorRequest::~CreateDataConnectorRequest() noexcept { +} + +CreateDataConnectorRequest::CreateDataConnectorRequest() noexcept { +} + +void CreateDataConnectorRequest::__set_connector(const DataConnector& val) { + this->connector = val; +} +std::ostream& operator<<(std::ostream& out, const CreateDataConnectorRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t CreateDataConnectorRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_connector = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->connector.read(iprot); + isset_connector = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_connector) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t CreateDataConnectorRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CreateDataConnectorRequest"); + + xfer += oprot->writeFieldBegin("connector", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->connector.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CreateDataConnectorRequest &a, CreateDataConnectorRequest &b) noexcept { + using ::std::swap; + swap(a.connector, b.connector); +} + +bool CreateDataConnectorRequest::operator==(const CreateDataConnectorRequest & rhs) const +{ + if (!(connector == rhs.connector)) + return false; + return true; +} + +CreateDataConnectorRequest::CreateDataConnectorRequest(const CreateDataConnectorRequest& other1631) { + connector = other1631.connector; +} +CreateDataConnectorRequest& CreateDataConnectorRequest::operator=(const CreateDataConnectorRequest& other1632) { + connector = other1632.connector; + return *this; +} +void CreateDataConnectorRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CreateDataConnectorRequest("; + out << "connector=" << to_string(connector); + out << ")"; +} + + +GetDataConnectorRequest::~GetDataConnectorRequest() noexcept { +} + +GetDataConnectorRequest::GetDataConnectorRequest() noexcept + : connectorName() { +} + +void GetDataConnectorRequest::__set_connectorName(const std::string& val) { + this->connectorName = val; +} +std::ostream& operator<<(std::ostream& out, const GetDataConnectorRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetDataConnectorRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_connectorName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->connectorName); + isset_connectorName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_connectorName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetDataConnectorRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetDataConnectorRequest"); + + xfer += oprot->writeFieldBegin("connectorName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->connectorName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetDataConnectorRequest &a, GetDataConnectorRequest &b) noexcept { + using ::std::swap; + swap(a.connectorName, b.connectorName); +} + +bool GetDataConnectorRequest::operator==(const GetDataConnectorRequest & rhs) const +{ + if (!(connectorName == rhs.connectorName)) + return false; + return true; +} + +GetDataConnectorRequest::GetDataConnectorRequest(const GetDataConnectorRequest& other1633) { + connectorName = other1633.connectorName; +} +GetDataConnectorRequest& GetDataConnectorRequest::operator=(const GetDataConnectorRequest& other1634) { + connectorName = other1634.connectorName; + return *this; +} +void GetDataConnectorRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetDataConnectorRequest("; + out << "connectorName=" << to_string(connectorName); + out << ")"; +} + + +AlterDataConnectorRequest::~AlterDataConnectorRequest() noexcept { +} + +AlterDataConnectorRequest::AlterDataConnectorRequest() noexcept + : connectorName() { +} + +void AlterDataConnectorRequest::__set_connectorName(const std::string& val) { + this->connectorName = val; +} + +void AlterDataConnectorRequest::__set_newConnector(const DataConnector& val) { + this->newConnector = val; +} +std::ostream& operator<<(std::ostream& out, const AlterDataConnectorRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AlterDataConnectorRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_connectorName = false; + bool isset_newConnector = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->connectorName); + isset_connectorName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->newConnector.read(iprot); + isset_newConnector = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_connectorName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_newConnector) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AlterDataConnectorRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AlterDataConnectorRequest"); + + xfer += oprot->writeFieldBegin("connectorName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->connectorName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("newConnector", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->newConnector.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AlterDataConnectorRequest &a, AlterDataConnectorRequest &b) noexcept { + using ::std::swap; + swap(a.connectorName, b.connectorName); + swap(a.newConnector, b.newConnector); +} + +bool AlterDataConnectorRequest::operator==(const AlterDataConnectorRequest & rhs) const +{ + if (!(connectorName == rhs.connectorName)) + return false; + if (!(newConnector == rhs.newConnector)) + return false; + return true; +} + +AlterDataConnectorRequest::AlterDataConnectorRequest(const AlterDataConnectorRequest& other1635) { + connectorName = other1635.connectorName; + newConnector = other1635.newConnector; +} +AlterDataConnectorRequest& AlterDataConnectorRequest::operator=(const AlterDataConnectorRequest& other1636) { + connectorName = other1636.connectorName; + newConnector = other1636.newConnector; + return *this; +} +void AlterDataConnectorRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AlterDataConnectorRequest("; + out << "connectorName=" << to_string(connectorName); + out << ", " << "newConnector=" << to_string(newConnector); + out << ")"; +} + + +DropDataConnectorRequest::~DropDataConnectorRequest() noexcept { +} + +DropDataConnectorRequest::DropDataConnectorRequest() noexcept + : connectorName(), + ifNotExists(0), + checkReferences(0) { +} + +void DropDataConnectorRequest::__set_connectorName(const std::string& val) { + this->connectorName = val; +} + +void DropDataConnectorRequest::__set_ifNotExists(const bool val) { + this->ifNotExists = val; +__isset.ifNotExists = true; +} + +void DropDataConnectorRequest::__set_checkReferences(const bool val) { + this->checkReferences = val; +__isset.checkReferences = true; +} +std::ostream& operator<<(std::ostream& out, const DropDataConnectorRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t DropDataConnectorRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_connectorName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->connectorName); + isset_connectorName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->ifNotExists); + this->__isset.ifNotExists = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->checkReferences); + this->__isset.checkReferences = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_connectorName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t DropDataConnectorRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("DropDataConnectorRequest"); + + xfer += oprot->writeFieldBegin("connectorName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->connectorName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.ifNotExists) { + xfer += oprot->writeFieldBegin("ifNotExists", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool(this->ifNotExists); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.checkReferences) { + xfer += oprot->writeFieldBegin("checkReferences", ::apache::thrift::protocol::T_BOOL, 3); + xfer += oprot->writeBool(this->checkReferences); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(DropDataConnectorRequest &a, DropDataConnectorRequest &b) noexcept { + using ::std::swap; + swap(a.connectorName, b.connectorName); + swap(a.ifNotExists, b.ifNotExists); + swap(a.checkReferences, b.checkReferences); + swap(a.__isset, b.__isset); +} + +bool DropDataConnectorRequest::operator==(const DropDataConnectorRequest & rhs) const +{ + if (!(connectorName == rhs.connectorName)) + return false; + if (__isset.ifNotExists != rhs.__isset.ifNotExists) + return false; + else if (__isset.ifNotExists && !(ifNotExists == rhs.ifNotExists)) + return false; + if (__isset.checkReferences != rhs.__isset.checkReferences) + return false; + else if (__isset.checkReferences && !(checkReferences == rhs.checkReferences)) + return false; + return true; +} + +DropDataConnectorRequest::DropDataConnectorRequest(const DropDataConnectorRequest& other1637) { + connectorName = other1637.connectorName; + ifNotExists = other1637.ifNotExists; + checkReferences = other1637.checkReferences; + __isset = other1637.__isset; +} +DropDataConnectorRequest& DropDataConnectorRequest::operator=(const DropDataConnectorRequest& other1638) { + connectorName = other1638.connectorName; + ifNotExists = other1638.ifNotExists; + checkReferences = other1638.checkReferences; + __isset = other1638.__isset; + return *this; +} +void DropDataConnectorRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "DropDataConnectorRequest("; + out << "connectorName=" << to_string(connectorName); + out << ", " << "ifNotExists="; (__isset.ifNotExists ? (out << to_string(ifNotExists)) : (out << "")); + out << ", " << "checkReferences="; (__isset.checkReferences ? (out << to_string(checkReferences)) : (out << "")); + out << ")"; +} + + +ScheduledQueryPollRequest::~ScheduledQueryPollRequest() noexcept { +} + +ScheduledQueryPollRequest::ScheduledQueryPollRequest() noexcept + : clusterNamespace() { +} + +void ScheduledQueryPollRequest::__set_clusterNamespace(const std::string& val) { + this->clusterNamespace = val; +} +std::ostream& operator<<(std::ostream& out, const ScheduledQueryPollRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ScheduledQueryPollRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_clusterNamespace = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->clusterNamespace); + isset_clusterNamespace = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_clusterNamespace) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ScheduledQueryPollRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ScheduledQueryPollRequest"); + + xfer += oprot->writeFieldBegin("clusterNamespace", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->clusterNamespace); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ScheduledQueryPollRequest &a, ScheduledQueryPollRequest &b) noexcept { + using ::std::swap; + swap(a.clusterNamespace, b.clusterNamespace); +} + +bool ScheduledQueryPollRequest::operator==(const ScheduledQueryPollRequest & rhs) const +{ + if (!(clusterNamespace == rhs.clusterNamespace)) + return false; + return true; +} + +ScheduledQueryPollRequest::ScheduledQueryPollRequest(const ScheduledQueryPollRequest& other1639) { + clusterNamespace = other1639.clusterNamespace; +} +ScheduledQueryPollRequest& ScheduledQueryPollRequest::operator=(const ScheduledQueryPollRequest& other1640) { + clusterNamespace = other1640.clusterNamespace; + return *this; +} +void ScheduledQueryPollRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ScheduledQueryPollRequest("; + out << "clusterNamespace=" << to_string(clusterNamespace); + out << ")"; +} + + +ScheduledQueryKey::~ScheduledQueryKey() noexcept { +} + +ScheduledQueryKey::ScheduledQueryKey() noexcept + : scheduleName(), + clusterNamespace() { +} + +void ScheduledQueryKey::__set_scheduleName(const std::string& val) { + this->scheduleName = val; +} + +void ScheduledQueryKey::__set_clusterNamespace(const std::string& val) { + this->clusterNamespace = val; +} +std::ostream& operator<<(std::ostream& out, const ScheduledQueryKey& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ScheduledQueryKey::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_scheduleName = false; + bool isset_clusterNamespace = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->scheduleName); + isset_scheduleName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->clusterNamespace); + isset_clusterNamespace = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_scheduleName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_clusterNamespace) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ScheduledQueryKey::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ScheduledQueryKey"); + + xfer += oprot->writeFieldBegin("scheduleName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->scheduleName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("clusterNamespace", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->clusterNamespace); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ScheduledQueryKey &a, ScheduledQueryKey &b) noexcept { + using ::std::swap; + swap(a.scheduleName, b.scheduleName); + swap(a.clusterNamespace, b.clusterNamespace); +} + +bool ScheduledQueryKey::operator==(const ScheduledQueryKey & rhs) const +{ + if (!(scheduleName == rhs.scheduleName)) + return false; + if (!(clusterNamespace == rhs.clusterNamespace)) + return false; + return true; +} + +ScheduledQueryKey::ScheduledQueryKey(const ScheduledQueryKey& other1641) { + scheduleName = other1641.scheduleName; + clusterNamespace = other1641.clusterNamespace; +} +ScheduledQueryKey& ScheduledQueryKey::operator=(const ScheduledQueryKey& other1642) { + scheduleName = other1642.scheduleName; + clusterNamespace = other1642.clusterNamespace; + return *this; +} +void ScheduledQueryKey::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ScheduledQueryKey("; + out << "scheduleName=" << to_string(scheduleName); + out << ", " << "clusterNamespace=" << to_string(clusterNamespace); + out << ")"; +} + + +ScheduledQueryPollResponse::~ScheduledQueryPollResponse() noexcept { +} + +ScheduledQueryPollResponse::ScheduledQueryPollResponse() noexcept + : executionId(0), + query(), + user() { +} + +void ScheduledQueryPollResponse::__set_scheduleKey(const ScheduledQueryKey& val) { + this->scheduleKey = val; +__isset.scheduleKey = true; +} + +void ScheduledQueryPollResponse::__set_executionId(const int64_t val) { + this->executionId = val; +__isset.executionId = true; +} + +void ScheduledQueryPollResponse::__set_query(const std::string& val) { + this->query = val; +__isset.query = true; +} + +void ScheduledQueryPollResponse::__set_user(const std::string& val) { + this->user = val; +__isset.user = true; +} +std::ostream& operator<<(std::ostream& out, const ScheduledQueryPollResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ScheduledQueryPollResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->scheduleKey.read(iprot); + this->__isset.scheduleKey = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->executionId); + this->__isset.executionId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->query); + this->__isset.query = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->user); + this->__isset.user = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ScheduledQueryPollResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ScheduledQueryPollResponse"); + + if (this->__isset.scheduleKey) { + xfer += oprot->writeFieldBegin("scheduleKey", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->scheduleKey.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.executionId) { + xfer += oprot->writeFieldBegin("executionId", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->executionId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.query) { + xfer += oprot->writeFieldBegin("query", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->query); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.user) { + xfer += oprot->writeFieldBegin("user", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->user); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ScheduledQueryPollResponse &a, ScheduledQueryPollResponse &b) noexcept { + using ::std::swap; + swap(a.scheduleKey, b.scheduleKey); + swap(a.executionId, b.executionId); + swap(a.query, b.query); + swap(a.user, b.user); + swap(a.__isset, b.__isset); +} + +bool ScheduledQueryPollResponse::operator==(const ScheduledQueryPollResponse & rhs) const +{ + if (__isset.scheduleKey != rhs.__isset.scheduleKey) + return false; + else if (__isset.scheduleKey && !(scheduleKey == rhs.scheduleKey)) + return false; + if (__isset.executionId != rhs.__isset.executionId) + return false; + else if (__isset.executionId && !(executionId == rhs.executionId)) + return false; + if (__isset.query != rhs.__isset.query) + return false; + else if (__isset.query && !(query == rhs.query)) + return false; + if (__isset.user != rhs.__isset.user) + return false; + else if (__isset.user && !(user == rhs.user)) + return false; + return true; +} + +ScheduledQueryPollResponse::ScheduledQueryPollResponse(const ScheduledQueryPollResponse& other1643) { + scheduleKey = other1643.scheduleKey; + executionId = other1643.executionId; + query = other1643.query; + user = other1643.user; + __isset = other1643.__isset; +} +ScheduledQueryPollResponse& ScheduledQueryPollResponse::operator=(const ScheduledQueryPollResponse& other1644) { + scheduleKey = other1644.scheduleKey; + executionId = other1644.executionId; + query = other1644.query; + user = other1644.user; + __isset = other1644.__isset; + return *this; +} +void ScheduledQueryPollResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ScheduledQueryPollResponse("; + out << "scheduleKey="; (__isset.scheduleKey ? (out << to_string(scheduleKey)) : (out << "")); + out << ", " << "executionId="; (__isset.executionId ? (out << to_string(executionId)) : (out << "")); + out << ", " << "query="; (__isset.query ? (out << to_string(query)) : (out << "")); + out << ", " << "user="; (__isset.user ? (out << to_string(user)) : (out << "")); + out << ")"; +} + + +ScheduledQuery::~ScheduledQuery() noexcept { +} + +ScheduledQuery::ScheduledQuery() noexcept + : enabled(0), + schedule(), + user(), + query(), + nextExecution(0) { +} + +void ScheduledQuery::__set_scheduleKey(const ScheduledQueryKey& val) { + this->scheduleKey = val; +} + +void ScheduledQuery::__set_enabled(const bool val) { + this->enabled = val; +__isset.enabled = true; +} + +void ScheduledQuery::__set_schedule(const std::string& val) { + this->schedule = val; +__isset.schedule = true; +} + +void ScheduledQuery::__set_user(const std::string& val) { + this->user = val; +__isset.user = true; +} + +void ScheduledQuery::__set_query(const std::string& val) { + this->query = val; +__isset.query = true; +} + +void ScheduledQuery::__set_nextExecution(const int32_t val) { + this->nextExecution = val; +__isset.nextExecution = true; +} +std::ostream& operator<<(std::ostream& out, const ScheduledQuery& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ScheduledQuery::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_scheduleKey = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->scheduleKey.read(iprot); + isset_scheduleKey = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->enabled); + this->__isset.enabled = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->schedule); + this->__isset.schedule = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->user); + this->__isset.user = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->query); + this->__isset.query = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->nextExecution); + this->__isset.nextExecution = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_scheduleKey) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ScheduledQuery::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ScheduledQuery"); + + xfer += oprot->writeFieldBegin("scheduleKey", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->scheduleKey.write(oprot); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.enabled) { + xfer += oprot->writeFieldBegin("enabled", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool(this->enabled); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.schedule) { + xfer += oprot->writeFieldBegin("schedule", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->schedule); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.user) { + xfer += oprot->writeFieldBegin("user", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->user); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.query) { + xfer += oprot->writeFieldBegin("query", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->query); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.nextExecution) { + xfer += oprot->writeFieldBegin("nextExecution", ::apache::thrift::protocol::T_I32, 7); + xfer += oprot->writeI32(this->nextExecution); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ScheduledQuery &a, ScheduledQuery &b) noexcept { + using ::std::swap; + swap(a.scheduleKey, b.scheduleKey); + swap(a.enabled, b.enabled); + swap(a.schedule, b.schedule); + swap(a.user, b.user); + swap(a.query, b.query); + swap(a.nextExecution, b.nextExecution); + swap(a.__isset, b.__isset); +} + +bool ScheduledQuery::operator==(const ScheduledQuery & rhs) const +{ + if (!(scheduleKey == rhs.scheduleKey)) + return false; + if (__isset.enabled != rhs.__isset.enabled) + return false; + else if (__isset.enabled && !(enabled == rhs.enabled)) + return false; + if (__isset.schedule != rhs.__isset.schedule) + return false; + else if (__isset.schedule && !(schedule == rhs.schedule)) + return false; + if (__isset.user != rhs.__isset.user) + return false; + else if (__isset.user && !(user == rhs.user)) + return false; + if (__isset.query != rhs.__isset.query) + return false; + else if (__isset.query && !(query == rhs.query)) + return false; + if (__isset.nextExecution != rhs.__isset.nextExecution) + return false; + else if (__isset.nextExecution && !(nextExecution == rhs.nextExecution)) + return false; + return true; +} + +ScheduledQuery::ScheduledQuery(const ScheduledQuery& other1645) { + scheduleKey = other1645.scheduleKey; + enabled = other1645.enabled; + schedule = other1645.schedule; + user = other1645.user; + query = other1645.query; + nextExecution = other1645.nextExecution; + __isset = other1645.__isset; +} +ScheduledQuery& ScheduledQuery::operator=(const ScheduledQuery& other1646) { + scheduleKey = other1646.scheduleKey; + enabled = other1646.enabled; + schedule = other1646.schedule; + user = other1646.user; + query = other1646.query; + nextExecution = other1646.nextExecution; + __isset = other1646.__isset; + return *this; +} +void ScheduledQuery::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ScheduledQuery("; + out << "scheduleKey=" << to_string(scheduleKey); + out << ", " << "enabled="; (__isset.enabled ? (out << to_string(enabled)) : (out << "")); + out << ", " << "schedule="; (__isset.schedule ? (out << to_string(schedule)) : (out << "")); + out << ", " << "user="; (__isset.user ? (out << to_string(user)) : (out << "")); + out << ", " << "query="; (__isset.query ? (out << to_string(query)) : (out << "")); + out << ", " << "nextExecution="; (__isset.nextExecution ? (out << to_string(nextExecution)) : (out << "")); + out << ")"; +} + + +ScheduledQueryMaintenanceRequest::~ScheduledQueryMaintenanceRequest() noexcept { +} + +ScheduledQueryMaintenanceRequest::ScheduledQueryMaintenanceRequest() noexcept + : type(static_cast(0)) { +} + +void ScheduledQueryMaintenanceRequest::__set_type(const ScheduledQueryMaintenanceRequestType::type val) { + this->type = val; +} + +void ScheduledQueryMaintenanceRequest::__set_scheduledQuery(const ScheduledQuery& val) { + this->scheduledQuery = val; +} +std::ostream& operator<<(std::ostream& out, const ScheduledQueryMaintenanceRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ScheduledQueryMaintenanceRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_type = false; + bool isset_scheduledQuery = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1647; + xfer += iprot->readI32(ecast1647); + this->type = static_cast(ecast1647); + isset_type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->scheduledQuery.read(iprot); + isset_scheduledQuery = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_type) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_scheduledQuery) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ScheduledQueryMaintenanceRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ScheduledQueryMaintenanceRequest"); + + xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32(static_cast(this->type)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("scheduledQuery", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->scheduledQuery.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ScheduledQueryMaintenanceRequest &a, ScheduledQueryMaintenanceRequest &b) noexcept { + using ::std::swap; + swap(a.type, b.type); + swap(a.scheduledQuery, b.scheduledQuery); +} + +bool ScheduledQueryMaintenanceRequest::operator==(const ScheduledQueryMaintenanceRequest & rhs) const +{ + if (!(type == rhs.type)) + return false; + if (!(scheduledQuery == rhs.scheduledQuery)) + return false; + return true; +} + +ScheduledQueryMaintenanceRequest::ScheduledQueryMaintenanceRequest(const ScheduledQueryMaintenanceRequest& other1648) { + type = other1648.type; + scheduledQuery = other1648.scheduledQuery; +} +ScheduledQueryMaintenanceRequest& ScheduledQueryMaintenanceRequest::operator=(const ScheduledQueryMaintenanceRequest& other1649) { + type = other1649.type; + scheduledQuery = other1649.scheduledQuery; + return *this; +} +void ScheduledQueryMaintenanceRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ScheduledQueryMaintenanceRequest("; + out << "type=" << to_string(type); + out << ", " << "scheduledQuery=" << to_string(scheduledQuery); + out << ")"; +} + + +ScheduledQueryProgressInfo::~ScheduledQueryProgressInfo() noexcept { +} + +ScheduledQueryProgressInfo::ScheduledQueryProgressInfo() noexcept + : scheduledExecutionId(0), + state(static_cast(0)), + executorQueryId(), + errorMessage() { +} + +void ScheduledQueryProgressInfo::__set_scheduledExecutionId(const int64_t val) { + this->scheduledExecutionId = val; +} + +void ScheduledQueryProgressInfo::__set_state(const QueryState::type val) { + this->state = val; +} + +void ScheduledQueryProgressInfo::__set_executorQueryId(const std::string& val) { + this->executorQueryId = val; +} + +void ScheduledQueryProgressInfo::__set_errorMessage(const std::string& val) { + this->errorMessage = val; +__isset.errorMessage = true; +} +std::ostream& operator<<(std::ostream& out, const ScheduledQueryProgressInfo& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ScheduledQueryProgressInfo::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_scheduledExecutionId = false; + bool isset_state = false; + bool isset_executorQueryId = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->scheduledExecutionId); + isset_scheduledExecutionId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1650; + xfer += iprot->readI32(ecast1650); + this->state = static_cast(ecast1650); + isset_state = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->executorQueryId); + isset_executorQueryId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->errorMessage); + this->__isset.errorMessage = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_scheduledExecutionId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_state) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_executorQueryId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ScheduledQueryProgressInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ScheduledQueryProgressInfo"); + + xfer += oprot->writeFieldBegin("scheduledExecutionId", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->scheduledExecutionId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(static_cast(this->state)); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("executorQueryId", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->executorQueryId); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.errorMessage) { + xfer += oprot->writeFieldBegin("errorMessage", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->errorMessage); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ScheduledQueryProgressInfo &a, ScheduledQueryProgressInfo &b) noexcept { + using ::std::swap; + swap(a.scheduledExecutionId, b.scheduledExecutionId); + swap(a.state, b.state); + swap(a.executorQueryId, b.executorQueryId); + swap(a.errorMessage, b.errorMessage); + swap(a.__isset, b.__isset); +} + +bool ScheduledQueryProgressInfo::operator==(const ScheduledQueryProgressInfo & rhs) const +{ + if (!(scheduledExecutionId == rhs.scheduledExecutionId)) + return false; + if (!(state == rhs.state)) + return false; + if (!(executorQueryId == rhs.executorQueryId)) + return false; + if (__isset.errorMessage != rhs.__isset.errorMessage) + return false; + else if (__isset.errorMessage && !(errorMessage == rhs.errorMessage)) + return false; + return true; +} + +ScheduledQueryProgressInfo::ScheduledQueryProgressInfo(const ScheduledQueryProgressInfo& other1651) { + scheduledExecutionId = other1651.scheduledExecutionId; + state = other1651.state; + executorQueryId = other1651.executorQueryId; + errorMessage = other1651.errorMessage; + __isset = other1651.__isset; +} +ScheduledQueryProgressInfo& ScheduledQueryProgressInfo::operator=(const ScheduledQueryProgressInfo& other1652) { + scheduledExecutionId = other1652.scheduledExecutionId; + state = other1652.state; + executorQueryId = other1652.executorQueryId; + errorMessage = other1652.errorMessage; + __isset = other1652.__isset; + return *this; +} +void ScheduledQueryProgressInfo::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ScheduledQueryProgressInfo("; + out << "scheduledExecutionId=" << to_string(scheduledExecutionId); + out << ", " << "state=" << to_string(state); + out << ", " << "executorQueryId=" << to_string(executorQueryId); + out << ", " << "errorMessage="; (__isset.errorMessage ? (out << to_string(errorMessage)) : (out << "")); + out << ")"; +} + + +AlterPartitionsRequest::~AlterPartitionsRequest() noexcept { +} + +AlterPartitionsRequest::AlterPartitionsRequest() noexcept + : catName(), + dbName(), + tableName(), + writeId(-1LL), + validWriteIdList(), + skipColumnSchemaForPartition(0) { +} + +void AlterPartitionsRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void AlterPartitionsRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void AlterPartitionsRequest::__set_tableName(const std::string& val) { + this->tableName = val; +} + +void AlterPartitionsRequest::__set_partitions(const std::vector & val) { + this->partitions = val; +} + +void AlterPartitionsRequest::__set_environmentContext(const EnvironmentContext& val) { + this->environmentContext = val; +__isset.environmentContext = true; +} + +void AlterPartitionsRequest::__set_writeId(const int64_t val) { + this->writeId = val; +__isset.writeId = true; +} + +void AlterPartitionsRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void AlterPartitionsRequest::__set_skipColumnSchemaForPartition(const bool val) { + this->skipColumnSchemaForPartition = val; +__isset.skipColumnSchemaForPartition = true; +} + +void AlterPartitionsRequest::__set_partitionColSchema(const std::vector & val) { + this->partitionColSchema = val; +__isset.partitionColSchema = true; +} +std::ostream& operator<<(std::ostream& out, const AlterPartitionsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AlterPartitionsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tableName = false; + bool isset_partitions = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + isset_tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitions.clear(); + uint32_t _size1653; + ::apache::thrift::protocol::TType _etype1656; + xfer += iprot->readListBegin(_etype1656, _size1653); + this->partitions.resize(_size1653); + uint32_t _i1657; + for (_i1657 = 0; _i1657 < _size1653; ++_i1657) + { + xfer += this->partitions[_i1657].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_partitions = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->environmentContext.read(iprot); + this->__isset.environmentContext = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->writeId); + this->__isset.writeId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->skipColumnSchemaForPartition); + this->__isset.skipColumnSchemaForPartition = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitionColSchema.clear(); + uint32_t _size1658; + ::apache::thrift::protocol::TType _etype1661; + xfer += iprot->readListBegin(_etype1661, _size1658); + this->partitionColSchema.resize(_size1658); + uint32_t _i1662; + for (_i1662 = 0; _i1662 < _size1658; ++_i1662) + { + xfer += this->partitionColSchema[_i1662].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.partitionColSchema = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tableName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_partitions) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AlterPartitionsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AlterPartitionsRequest"); + + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); + std::vector ::const_iterator _iter1663; + for (_iter1663 = this->partitions.begin(); _iter1663 != this->partitions.end(); ++_iter1663) + { + xfer += (*_iter1663).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.environmentContext) { + xfer += oprot->writeFieldBegin("environmentContext", ::apache::thrift::protocol::T_STRUCT, 5); + xfer += this->environmentContext.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.writeId) { + xfer += oprot->writeFieldBegin("writeId", ::apache::thrift::protocol::T_I64, 6); + xfer += oprot->writeI64(this->writeId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 7); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.skipColumnSchemaForPartition) { + xfer += oprot->writeFieldBegin("skipColumnSchemaForPartition", ::apache::thrift::protocol::T_BOOL, 8); + xfer += oprot->writeBool(this->skipColumnSchemaForPartition); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.partitionColSchema) { + xfer += oprot->writeFieldBegin("partitionColSchema", ::apache::thrift::protocol::T_LIST, 9); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionColSchema.size())); + std::vector ::const_iterator _iter1664; + for (_iter1664 = this->partitionColSchema.begin(); _iter1664 != this->partitionColSchema.end(); ++_iter1664) + { + xfer += (*_iter1664).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AlterPartitionsRequest &a, AlterPartitionsRequest &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.dbName, b.dbName); + swap(a.tableName, b.tableName); + swap(a.partitions, b.partitions); + swap(a.environmentContext, b.environmentContext); + swap(a.writeId, b.writeId); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.skipColumnSchemaForPartition, b.skipColumnSchemaForPartition); + swap(a.partitionColSchema, b.partitionColSchema); + swap(a.__isset, b.__isset); +} + +bool AlterPartitionsRequest::operator==(const AlterPartitionsRequest & rhs) const +{ + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(partitions == rhs.partitions)) + return false; + if (__isset.environmentContext != rhs.__isset.environmentContext) + return false; + else if (__isset.environmentContext && !(environmentContext == rhs.environmentContext)) + return false; + if (__isset.writeId != rhs.__isset.writeId) + return false; + else if (__isset.writeId && !(writeId == rhs.writeId)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.skipColumnSchemaForPartition != rhs.__isset.skipColumnSchemaForPartition) + return false; + else if (__isset.skipColumnSchemaForPartition && !(skipColumnSchemaForPartition == rhs.skipColumnSchemaForPartition)) + return false; + if (__isset.partitionColSchema != rhs.__isset.partitionColSchema) + return false; + else if (__isset.partitionColSchema && !(partitionColSchema == rhs.partitionColSchema)) + return false; + return true; +} + +AlterPartitionsRequest::AlterPartitionsRequest(const AlterPartitionsRequest& other1665) { + catName = other1665.catName; + dbName = other1665.dbName; + tableName = other1665.tableName; + partitions = other1665.partitions; + environmentContext = other1665.environmentContext; + writeId = other1665.writeId; + validWriteIdList = other1665.validWriteIdList; + skipColumnSchemaForPartition = other1665.skipColumnSchemaForPartition; + partitionColSchema = other1665.partitionColSchema; + __isset = other1665.__isset; +} +AlterPartitionsRequest& AlterPartitionsRequest::operator=(const AlterPartitionsRequest& other1666) { + catName = other1666.catName; + dbName = other1666.dbName; + tableName = other1666.tableName; + partitions = other1666.partitions; + environmentContext = other1666.environmentContext; + writeId = other1666.writeId; + validWriteIdList = other1666.validWriteIdList; + skipColumnSchemaForPartition = other1666.skipColumnSchemaForPartition; + partitionColSchema = other1666.partitionColSchema; + __isset = other1666.__isset; + return *this; +} +void AlterPartitionsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AlterPartitionsRequest("; + out << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "tableName=" << to_string(tableName); + out << ", " << "partitions=" << to_string(partitions); + out << ", " << "environmentContext="; (__isset.environmentContext ? (out << to_string(environmentContext)) : (out << "")); + out << ", " << "writeId="; (__isset.writeId ? (out << to_string(writeId)) : (out << "")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "skipColumnSchemaForPartition="; (__isset.skipColumnSchemaForPartition ? (out << to_string(skipColumnSchemaForPartition)) : (out << "")); + out << ", " << "partitionColSchema="; (__isset.partitionColSchema ? (out << to_string(partitionColSchema)) : (out << "")); + out << ")"; +} + + +AppendPartitionsRequest::~AppendPartitionsRequest() noexcept { +} + +AppendPartitionsRequest::AppendPartitionsRequest() noexcept + : catalogName(), + dbName(), + tableName(), + name() { +} + +void AppendPartitionsRequest::__set_catalogName(const std::string& val) { + this->catalogName = val; +__isset.catalogName = true; +} + +void AppendPartitionsRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void AppendPartitionsRequest::__set_tableName(const std::string& val) { + this->tableName = val; +} + +void AppendPartitionsRequest::__set_name(const std::string& val) { + this->name = val; +__isset.name = true; +} + +void AppendPartitionsRequest::__set_partVals(const std::vector & val) { + this->partVals = val; +__isset.partVals = true; +} + +void AppendPartitionsRequest::__set_environmentContext(const EnvironmentContext& val) { + this->environmentContext = val; +__isset.environmentContext = true; +} +std::ostream& operator<<(std::ostream& out, const AppendPartitionsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AppendPartitionsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tableName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catalogName); + this->__isset.catalogName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + isset_tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partVals.clear(); + uint32_t _size1667; + ::apache::thrift::protocol::TType _etype1670; + xfer += iprot->readListBegin(_etype1670, _size1667); + this->partVals.resize(_size1667); + uint32_t _i1671; + for (_i1671 = 0; _i1671 < _size1667; ++_i1671) + { + xfer += iprot->readString(this->partVals[_i1671]); + } + xfer += iprot->readListEnd(); + } + this->__isset.partVals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->environmentContext.read(iprot); + this->__isset.environmentContext = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tableName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AppendPartitionsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AppendPartitionsRequest"); + + if (this->__isset.catalogName) { + xfer += oprot->writeFieldBegin("catalogName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catalogName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.name) { + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.partVals) { + xfer += oprot->writeFieldBegin("partVals", ::apache::thrift::protocol::T_LIST, 5); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partVals.size())); + std::vector ::const_iterator _iter1672; + for (_iter1672 = this->partVals.begin(); _iter1672 != this->partVals.end(); ++_iter1672) + { + xfer += oprot->writeString((*_iter1672)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.environmentContext) { + xfer += oprot->writeFieldBegin("environmentContext", ::apache::thrift::protocol::T_STRUCT, 6); + xfer += this->environmentContext.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AppendPartitionsRequest &a, AppendPartitionsRequest &b) noexcept { + using ::std::swap; + swap(a.catalogName, b.catalogName); + swap(a.dbName, b.dbName); + swap(a.tableName, b.tableName); + swap(a.name, b.name); + swap(a.partVals, b.partVals); + swap(a.environmentContext, b.environmentContext); + swap(a.__isset, b.__isset); +} + +bool AppendPartitionsRequest::operator==(const AppendPartitionsRequest & rhs) const +{ + if (__isset.catalogName != rhs.__isset.catalogName) + return false; + else if (__isset.catalogName && !(catalogName == rhs.catalogName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (__isset.name != rhs.__isset.name) + return false; + else if (__isset.name && !(name == rhs.name)) + return false; + if (__isset.partVals != rhs.__isset.partVals) + return false; + else if (__isset.partVals && !(partVals == rhs.partVals)) + return false; + if (__isset.environmentContext != rhs.__isset.environmentContext) + return false; + else if (__isset.environmentContext && !(environmentContext == rhs.environmentContext)) + return false; + return true; +} + +AppendPartitionsRequest::AppendPartitionsRequest(const AppendPartitionsRequest& other1673) { + catalogName = other1673.catalogName; + dbName = other1673.dbName; + tableName = other1673.tableName; + name = other1673.name; + partVals = other1673.partVals; + environmentContext = other1673.environmentContext; + __isset = other1673.__isset; +} +AppendPartitionsRequest& AppendPartitionsRequest::operator=(const AppendPartitionsRequest& other1674) { + catalogName = other1674.catalogName; + dbName = other1674.dbName; + tableName = other1674.tableName; + name = other1674.name; + partVals = other1674.partVals; + environmentContext = other1674.environmentContext; + __isset = other1674.__isset; + return *this; +} +void AppendPartitionsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AppendPartitionsRequest("; + out << "catalogName="; (__isset.catalogName ? (out << to_string(catalogName)) : (out << "")); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "tableName=" << to_string(tableName); + out << ", " << "name="; (__isset.name ? (out << to_string(name)) : (out << "")); + out << ", " << "partVals="; (__isset.partVals ? (out << to_string(partVals)) : (out << "")); + out << ", " << "environmentContext="; (__isset.environmentContext ? (out << to_string(environmentContext)) : (out << "")); + out << ")"; +} + + +AlterPartitionsResponse::~AlterPartitionsResponse() noexcept { +} + +AlterPartitionsResponse::AlterPartitionsResponse() noexcept { +} +std::ostream& operator<<(std::ostream& out, const AlterPartitionsResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AlterPartitionsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t AlterPartitionsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AlterPartitionsResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AlterPartitionsResponse &a, AlterPartitionsResponse &b) noexcept { + using ::std::swap; + (void) a; + (void) b; +} + +bool AlterPartitionsResponse::operator==(const AlterPartitionsResponse & /* rhs */) const +{ + return true; +} + +AlterPartitionsResponse::AlterPartitionsResponse(const AlterPartitionsResponse& other1675) noexcept { + (void) other1675; +} +AlterPartitionsResponse& AlterPartitionsResponse::operator=(const AlterPartitionsResponse& other1676) noexcept { + (void) other1676; + return *this; +} +void AlterPartitionsResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AlterPartitionsResponse("; + out << ")"; +} + + +RenamePartitionRequest::~RenamePartitionRequest() noexcept { +} + +RenamePartitionRequest::RenamePartitionRequest() noexcept + : catName(), + dbName(), + tableName(), + validWriteIdList(), + txnId(0), + clonePart(0) { +} + +void RenamePartitionRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void RenamePartitionRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void RenamePartitionRequest::__set_tableName(const std::string& val) { + this->tableName = val; +} + +void RenamePartitionRequest::__set_partVals(const std::vector & val) { + this->partVals = val; +} + +void RenamePartitionRequest::__set_newPart(const Partition& val) { + this->newPart = val; +} + +void RenamePartitionRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void RenamePartitionRequest::__set_txnId(const int64_t val) { + this->txnId = val; +__isset.txnId = true; +} + +void RenamePartitionRequest::__set_clonePart(const bool val) { + this->clonePart = val; +__isset.clonePart = true; +} +std::ostream& operator<<(std::ostream& out, const RenamePartitionRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t RenamePartitionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tableName = false; + bool isset_partVals = false; + bool isset_newPart = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + isset_tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partVals.clear(); + uint32_t _size1677; + ::apache::thrift::protocol::TType _etype1680; + xfer += iprot->readListBegin(_etype1680, _size1677); + this->partVals.resize(_size1677); + uint32_t _i1681; + for (_i1681 = 0; _i1681 < _size1677; ++_i1681) + { + xfer += iprot->readString(this->partVals[_i1681]); + } + xfer += iprot->readListEnd(); + } + isset_partVals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->newPart.read(iprot); + isset_newPart = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnId); + this->__isset.txnId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->clonePart); + this->__isset.clonePart = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tableName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_partVals) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_newPart) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t RenamePartitionRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("RenamePartitionRequest"); + + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("partVals", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partVals.size())); + std::vector ::const_iterator _iter1682; + for (_iter1682 = this->partVals.begin(); _iter1682 != this->partVals.end(); ++_iter1682) + { + xfer += oprot->writeString((*_iter1682)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("newPart", ::apache::thrift::protocol::T_STRUCT, 5); + xfer += this->newPart.write(oprot); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.txnId) { + xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 7); + xfer += oprot->writeI64(this->txnId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.clonePart) { + xfer += oprot->writeFieldBegin("clonePart", ::apache::thrift::protocol::T_BOOL, 8); + xfer += oprot->writeBool(this->clonePart); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(RenamePartitionRequest &a, RenamePartitionRequest &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.dbName, b.dbName); + swap(a.tableName, b.tableName); + swap(a.partVals, b.partVals); + swap(a.newPart, b.newPart); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.txnId, b.txnId); + swap(a.clonePart, b.clonePart); + swap(a.__isset, b.__isset); +} + +bool RenamePartitionRequest::operator==(const RenamePartitionRequest & rhs) const +{ + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(partVals == rhs.partVals)) + return false; + if (!(newPart == rhs.newPart)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.txnId != rhs.__isset.txnId) + return false; + else if (__isset.txnId && !(txnId == rhs.txnId)) + return false; + if (__isset.clonePart != rhs.__isset.clonePart) + return false; + else if (__isset.clonePart && !(clonePart == rhs.clonePart)) + return false; + return true; +} + +RenamePartitionRequest::RenamePartitionRequest(const RenamePartitionRequest& other1683) { + catName = other1683.catName; + dbName = other1683.dbName; + tableName = other1683.tableName; + partVals = other1683.partVals; + newPart = other1683.newPart; + validWriteIdList = other1683.validWriteIdList; + txnId = other1683.txnId; + clonePart = other1683.clonePart; + __isset = other1683.__isset; +} +RenamePartitionRequest& RenamePartitionRequest::operator=(const RenamePartitionRequest& other1684) { + catName = other1684.catName; + dbName = other1684.dbName; + tableName = other1684.tableName; + partVals = other1684.partVals; + newPart = other1684.newPart; + validWriteIdList = other1684.validWriteIdList; + txnId = other1684.txnId; + clonePart = other1684.clonePart; + __isset = other1684.__isset; + return *this; +} +void RenamePartitionRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "RenamePartitionRequest("; + out << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "tableName=" << to_string(tableName); + out << ", " << "partVals=" << to_string(partVals); + out << ", " << "newPart=" << to_string(newPart); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "txnId="; (__isset.txnId ? (out << to_string(txnId)) : (out << "")); + out << ", " << "clonePart="; (__isset.clonePart ? (out << to_string(clonePart)) : (out << "")); + out << ")"; +} + + +RenamePartitionResponse::~RenamePartitionResponse() noexcept { +} + +RenamePartitionResponse::RenamePartitionResponse() noexcept { +} +std::ostream& operator<<(std::ostream& out, const RenamePartitionResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t RenamePartitionResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t RenamePartitionResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("RenamePartitionResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(RenamePartitionResponse &a, RenamePartitionResponse &b) noexcept { + using ::std::swap; + (void) a; + (void) b; +} + +bool RenamePartitionResponse::operator==(const RenamePartitionResponse & /* rhs */) const +{ + return true; +} + +RenamePartitionResponse::RenamePartitionResponse(const RenamePartitionResponse& other1685) noexcept { + (void) other1685; +} +RenamePartitionResponse& RenamePartitionResponse::operator=(const RenamePartitionResponse& other1686) noexcept { + (void) other1686; + return *this; +} +void RenamePartitionResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "RenamePartitionResponse("; + out << ")"; +} + + +AlterTableRequest::~AlterTableRequest() noexcept { +} + +AlterTableRequest::AlterTableRequest() noexcept + : catName(), + dbName(), + tableName(), + writeId(-1LL), + validWriteIdList(), + processorIdentifier(), + expectedParameterKey(), + expectedParameterValue() { +} + +void AlterTableRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void AlterTableRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void AlterTableRequest::__set_tableName(const std::string& val) { + this->tableName = val; +} + +void AlterTableRequest::__set_table(const Table& val) { + this->table = val; +} + +void AlterTableRequest::__set_environmentContext(const EnvironmentContext& val) { + this->environmentContext = val; +__isset.environmentContext = true; +} + +void AlterTableRequest::__set_writeId(const int64_t val) { + this->writeId = val; +__isset.writeId = true; +} + +void AlterTableRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void AlterTableRequest::__set_processorCapabilities(const std::vector & val) { + this->processorCapabilities = val; +__isset.processorCapabilities = true; +} + +void AlterTableRequest::__set_processorIdentifier(const std::string& val) { + this->processorIdentifier = val; +__isset.processorIdentifier = true; +} + +void AlterTableRequest::__set_expectedParameterKey(const std::string& val) { + this->expectedParameterKey = val; +__isset.expectedParameterKey = true; +} + +void AlterTableRequest::__set_expectedParameterValue(const std::string& val) { + this->expectedParameterValue = val; +__isset.expectedParameterValue = true; +} +std::ostream& operator<<(std::ostream& out, const AlterTableRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AlterTableRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tableName = false; + bool isset_table = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + isset_tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->table.read(iprot); + isset_table = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->environmentContext.read(iprot); + this->__isset.environmentContext = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->writeId); + this->__isset.writeId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->processorCapabilities.clear(); + uint32_t _size1687; + ::apache::thrift::protocol::TType _etype1690; + xfer += iprot->readListBegin(_etype1690, _size1687); + this->processorCapabilities.resize(_size1687); + uint32_t _i1691; + for (_i1691 = 0; _i1691 < _size1687; ++_i1691) + { + xfer += iprot->readString(this->processorCapabilities[_i1691]); + } + xfer += iprot->readListEnd(); + } + this->__isset.processorCapabilities = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->processorIdentifier); + this->__isset.processorIdentifier = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->expectedParameterKey); + this->__isset.expectedParameterKey = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 11: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->expectedParameterValue); + this->__isset.expectedParameterValue = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tableName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_table) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AlterTableRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AlterTableRequest"); + + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->table.write(oprot); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.environmentContext) { + xfer += oprot->writeFieldBegin("environmentContext", ::apache::thrift::protocol::T_STRUCT, 5); + xfer += this->environmentContext.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.writeId) { + xfer += oprot->writeFieldBegin("writeId", ::apache::thrift::protocol::T_I64, 6); + xfer += oprot->writeI64(this->writeId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 7); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.processorCapabilities) { + xfer += oprot->writeFieldBegin("processorCapabilities", ::apache::thrift::protocol::T_LIST, 8); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->processorCapabilities.size())); + std::vector ::const_iterator _iter1692; + for (_iter1692 = this->processorCapabilities.begin(); _iter1692 != this->processorCapabilities.end(); ++_iter1692) + { + xfer += oprot->writeString((*_iter1692)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.processorIdentifier) { + xfer += oprot->writeFieldBegin("processorIdentifier", ::apache::thrift::protocol::T_STRING, 9); + xfer += oprot->writeString(this->processorIdentifier); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.expectedParameterKey) { + xfer += oprot->writeFieldBegin("expectedParameterKey", ::apache::thrift::protocol::T_STRING, 10); + xfer += oprot->writeString(this->expectedParameterKey); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.expectedParameterValue) { + xfer += oprot->writeFieldBegin("expectedParameterValue", ::apache::thrift::protocol::T_STRING, 11); + xfer += oprot->writeString(this->expectedParameterValue); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AlterTableRequest &a, AlterTableRequest &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.dbName, b.dbName); + swap(a.tableName, b.tableName); + swap(a.table, b.table); + swap(a.environmentContext, b.environmentContext); + swap(a.writeId, b.writeId); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.processorCapabilities, b.processorCapabilities); + swap(a.processorIdentifier, b.processorIdentifier); + swap(a.expectedParameterKey, b.expectedParameterKey); + swap(a.expectedParameterValue, b.expectedParameterValue); + swap(a.__isset, b.__isset); +} + +bool AlterTableRequest::operator==(const AlterTableRequest & rhs) const +{ + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(table == rhs.table)) + return false; + if (__isset.environmentContext != rhs.__isset.environmentContext) + return false; + else if (__isset.environmentContext && !(environmentContext == rhs.environmentContext)) + return false; + if (__isset.writeId != rhs.__isset.writeId) + return false; + else if (__isset.writeId && !(writeId == rhs.writeId)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.processorCapabilities != rhs.__isset.processorCapabilities) + return false; + else if (__isset.processorCapabilities && !(processorCapabilities == rhs.processorCapabilities)) + return false; + if (__isset.processorIdentifier != rhs.__isset.processorIdentifier) + return false; + else if (__isset.processorIdentifier && !(processorIdentifier == rhs.processorIdentifier)) + return false; + if (__isset.expectedParameterKey != rhs.__isset.expectedParameterKey) + return false; + else if (__isset.expectedParameterKey && !(expectedParameterKey == rhs.expectedParameterKey)) + return false; + if (__isset.expectedParameterValue != rhs.__isset.expectedParameterValue) + return false; + else if (__isset.expectedParameterValue && !(expectedParameterValue == rhs.expectedParameterValue)) + return false; + return true; +} + +AlterTableRequest::AlterTableRequest(const AlterTableRequest& other1693) { + catName = other1693.catName; + dbName = other1693.dbName; + tableName = other1693.tableName; + table = other1693.table; + environmentContext = other1693.environmentContext; + writeId = other1693.writeId; + validWriteIdList = other1693.validWriteIdList; + processorCapabilities = other1693.processorCapabilities; + processorIdentifier = other1693.processorIdentifier; + expectedParameterKey = other1693.expectedParameterKey; + expectedParameterValue = other1693.expectedParameterValue; + __isset = other1693.__isset; +} +AlterTableRequest& AlterTableRequest::operator=(const AlterTableRequest& other1694) { + catName = other1694.catName; + dbName = other1694.dbName; + tableName = other1694.tableName; + table = other1694.table; + environmentContext = other1694.environmentContext; + writeId = other1694.writeId; + validWriteIdList = other1694.validWriteIdList; + processorCapabilities = other1694.processorCapabilities; + processorIdentifier = other1694.processorIdentifier; + expectedParameterKey = other1694.expectedParameterKey; + expectedParameterValue = other1694.expectedParameterValue; + __isset = other1694.__isset; + return *this; +} +void AlterTableRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AlterTableRequest("; + out << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "tableName=" << to_string(tableName); + out << ", " << "table=" << to_string(table); + out << ", " << "environmentContext="; (__isset.environmentContext ? (out << to_string(environmentContext)) : (out << "")); + out << ", " << "writeId="; (__isset.writeId ? (out << to_string(writeId)) : (out << "")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "processorCapabilities="; (__isset.processorCapabilities ? (out << to_string(processorCapabilities)) : (out << "")); + out << ", " << "processorIdentifier="; (__isset.processorIdentifier ? (out << to_string(processorIdentifier)) : (out << "")); + out << ", " << "expectedParameterKey="; (__isset.expectedParameterKey ? (out << to_string(expectedParameterKey)) : (out << "")); + out << ", " << "expectedParameterValue="; (__isset.expectedParameterValue ? (out << to_string(expectedParameterValue)) : (out << "")); + out << ")"; +} + + +AlterTableResponse::~AlterTableResponse() noexcept { +} + +AlterTableResponse::AlterTableResponse() noexcept { +} +std::ostream& operator<<(std::ostream& out, const AlterTableResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AlterTableResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t AlterTableResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AlterTableResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AlterTableResponse &a, AlterTableResponse &b) noexcept { + using ::std::swap; + (void) a; + (void) b; +} + +bool AlterTableResponse::operator==(const AlterTableResponse & /* rhs */) const +{ + return true; +} + +AlterTableResponse::AlterTableResponse(const AlterTableResponse& other1695) noexcept { + (void) other1695; +} +AlterTableResponse& AlterTableResponse::operator=(const AlterTableResponse& other1696) noexcept { + (void) other1696; + return *this; +} +void AlterTableResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AlterTableResponse("; + out << ")"; +} + + +GetPartitionsFilterSpec::~GetPartitionsFilterSpec() noexcept { +} + +GetPartitionsFilterSpec::GetPartitionsFilterSpec() noexcept + : filterMode(static_cast(0)) { +} + +void GetPartitionsFilterSpec::__set_filterMode(const PartitionFilterMode::type val) { + this->filterMode = val; +__isset.filterMode = true; +} + +void GetPartitionsFilterSpec::__set_filters(const std::vector & val) { + this->filters = val; +__isset.filters = true; +} +std::ostream& operator<<(std::ostream& out, const GetPartitionsFilterSpec& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetPartitionsFilterSpec::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 7: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1697; + xfer += iprot->readI32(ecast1697); + this->filterMode = static_cast(ecast1697); + this->__isset.filterMode = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->filters.clear(); + uint32_t _size1698; + ::apache::thrift::protocol::TType _etype1701; + xfer += iprot->readListBegin(_etype1701, _size1698); + this->filters.resize(_size1698); + uint32_t _i1702; + for (_i1702 = 0; _i1702 < _size1698; ++_i1702) + { + xfer += iprot->readString(this->filters[_i1702]); + } + xfer += iprot->readListEnd(); + } + this->__isset.filters = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t GetPartitionsFilterSpec::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetPartitionsFilterSpec"); + + if (this->__isset.filterMode) { + xfer += oprot->writeFieldBegin("filterMode", ::apache::thrift::protocol::T_I32, 7); + xfer += oprot->writeI32(static_cast(this->filterMode)); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.filters) { + xfer += oprot->writeFieldBegin("filters", ::apache::thrift::protocol::T_LIST, 8); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->filters.size())); + std::vector ::const_iterator _iter1703; + for (_iter1703 = this->filters.begin(); _iter1703 != this->filters.end(); ++_iter1703) + { + xfer += oprot->writeString((*_iter1703)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetPartitionsFilterSpec &a, GetPartitionsFilterSpec &b) noexcept { + using ::std::swap; + swap(a.filterMode, b.filterMode); + swap(a.filters, b.filters); + swap(a.__isset, b.__isset); +} + +bool GetPartitionsFilterSpec::operator==(const GetPartitionsFilterSpec & rhs) const +{ + if (__isset.filterMode != rhs.__isset.filterMode) + return false; + else if (__isset.filterMode && !(filterMode == rhs.filterMode)) + return false; + if (__isset.filters != rhs.__isset.filters) + return false; + else if (__isset.filters && !(filters == rhs.filters)) + return false; + return true; +} + +GetPartitionsFilterSpec::GetPartitionsFilterSpec(const GetPartitionsFilterSpec& other1704) { + filterMode = other1704.filterMode; + filters = other1704.filters; + __isset = other1704.__isset; +} +GetPartitionsFilterSpec& GetPartitionsFilterSpec::operator=(const GetPartitionsFilterSpec& other1705) { + filterMode = other1705.filterMode; + filters = other1705.filters; + __isset = other1705.__isset; + return *this; +} +void GetPartitionsFilterSpec::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetPartitionsFilterSpec("; + out << "filterMode="; (__isset.filterMode ? (out << to_string(filterMode)) : (out << "")); + out << ", " << "filters="; (__isset.filters ? (out << to_string(filters)) : (out << "")); + out << ")"; +} + + +GetPartitionsResponse::~GetPartitionsResponse() noexcept { +} + +GetPartitionsResponse::GetPartitionsResponse() noexcept { +} + +void GetPartitionsResponse::__set_partitionSpec(const std::vector & val) { + this->partitionSpec = val; +} +std::ostream& operator<<(std::ostream& out, const GetPartitionsResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetPartitionsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitionSpec.clear(); + uint32_t _size1706; + ::apache::thrift::protocol::TType _etype1709; + xfer += iprot->readListBegin(_etype1709, _size1706); + this->partitionSpec.resize(_size1706); + uint32_t _i1710; + for (_i1710 = 0; _i1710 < _size1706; ++_i1710) + { + xfer += this->partitionSpec[_i1710].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.partitionSpec = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t GetPartitionsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetPartitionsResponse"); + + xfer += oprot->writeFieldBegin("partitionSpec", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionSpec.size())); + std::vector ::const_iterator _iter1711; + for (_iter1711 = this->partitionSpec.begin(); _iter1711 != this->partitionSpec.end(); ++_iter1711) + { + xfer += (*_iter1711).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetPartitionsResponse &a, GetPartitionsResponse &b) noexcept { + using ::std::swap; + swap(a.partitionSpec, b.partitionSpec); + swap(a.__isset, b.__isset); +} + +bool GetPartitionsResponse::operator==(const GetPartitionsResponse & rhs) const +{ + if (!(partitionSpec == rhs.partitionSpec)) + return false; + return true; +} + +GetPartitionsResponse::GetPartitionsResponse(const GetPartitionsResponse& other1712) { + partitionSpec = other1712.partitionSpec; + __isset = other1712.__isset; +} +GetPartitionsResponse& GetPartitionsResponse::operator=(const GetPartitionsResponse& other1713) { + partitionSpec = other1713.partitionSpec; + __isset = other1713.__isset; + return *this; +} +void GetPartitionsResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetPartitionsResponse("; + out << "partitionSpec=" << to_string(partitionSpec); + out << ")"; +} + + +GetPartitionsRequest::~GetPartitionsRequest() noexcept { +} + +GetPartitionsRequest::GetPartitionsRequest() noexcept + : catName(), + dbName(), + tblName(), + withAuth(0), + user(), + processorIdentifier(), + validWriteIdList() { +} + +void GetPartitionsRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void GetPartitionsRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void GetPartitionsRequest::__set_tblName(const std::string& val) { + this->tblName = val; +} + +void GetPartitionsRequest::__set_withAuth(const bool val) { + this->withAuth = val; +__isset.withAuth = true; +} + +void GetPartitionsRequest::__set_user(const std::string& val) { + this->user = val; +__isset.user = true; +} + +void GetPartitionsRequest::__set_groupNames(const std::vector & val) { + this->groupNames = val; +__isset.groupNames = true; +} + +void GetPartitionsRequest::__set_projectionSpec(const GetProjectionsSpec& val) { + this->projectionSpec = val; +} + +void GetPartitionsRequest::__set_filterSpec(const GetPartitionsFilterSpec& val) { + this->filterSpec = val; +} + +void GetPartitionsRequest::__set_processorCapabilities(const std::vector & val) { + this->processorCapabilities = val; +__isset.processorCapabilities = true; +} + +void GetPartitionsRequest::__set_processorIdentifier(const std::string& val) { + this->processorIdentifier = val; +__isset.processorIdentifier = true; +} + +void GetPartitionsRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} +std::ostream& operator<<(std::ostream& out, const GetPartitionsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetPartitionsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tblName); + this->__isset.tblName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->withAuth); + this->__isset.withAuth = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->user); + this->__isset.user = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->groupNames.clear(); + uint32_t _size1714; + ::apache::thrift::protocol::TType _etype1717; + xfer += iprot->readListBegin(_etype1717, _size1714); + this->groupNames.resize(_size1714); + uint32_t _i1718; + for (_i1718 = 0; _i1718 < _size1714; ++_i1718) + { + xfer += iprot->readString(this->groupNames[_i1718]); + } + xfer += iprot->readListEnd(); + } + this->__isset.groupNames = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->projectionSpec.read(iprot); + this->__isset.projectionSpec = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->filterSpec.read(iprot); + this->__isset.filterSpec = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->processorCapabilities.clear(); + uint32_t _size1719; + ::apache::thrift::protocol::TType _etype1722; + xfer += iprot->readListBegin(_etype1722, _size1719); + this->processorCapabilities.resize(_size1719); + uint32_t _i1723; + for (_i1723 = 0; _i1723 < _size1719; ++_i1723) + { + xfer += iprot->readString(this->processorCapabilities[_i1723]); + } + xfer += iprot->readListEnd(); + } + this->__isset.processorCapabilities = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->processorIdentifier); + this->__isset.processorIdentifier = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 11: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t GetPartitionsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetPartitionsRequest"); + + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tblName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.withAuth) { + xfer += oprot->writeFieldBegin("withAuth", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool(this->withAuth); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.user) { + xfer += oprot->writeFieldBegin("user", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->user); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.groupNames) { + xfer += oprot->writeFieldBegin("groupNames", ::apache::thrift::protocol::T_LIST, 6); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->groupNames.size())); + std::vector ::const_iterator _iter1724; + for (_iter1724 = this->groupNames.begin(); _iter1724 != this->groupNames.end(); ++_iter1724) + { + xfer += oprot->writeString((*_iter1724)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("projectionSpec", ::apache::thrift::protocol::T_STRUCT, 7); + xfer += this->projectionSpec.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("filterSpec", ::apache::thrift::protocol::T_STRUCT, 8); + xfer += this->filterSpec.write(oprot); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.processorCapabilities) { + xfer += oprot->writeFieldBegin("processorCapabilities", ::apache::thrift::protocol::T_LIST, 9); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->processorCapabilities.size())); + std::vector ::const_iterator _iter1725; + for (_iter1725 = this->processorCapabilities.begin(); _iter1725 != this->processorCapabilities.end(); ++_iter1725) + { + xfer += oprot->writeString((*_iter1725)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.processorIdentifier) { + xfer += oprot->writeFieldBegin("processorIdentifier", ::apache::thrift::protocol::T_STRING, 10); + xfer += oprot->writeString(this->processorIdentifier); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 11); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetPartitionsRequest &a, GetPartitionsRequest &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); + swap(a.withAuth, b.withAuth); + swap(a.user, b.user); + swap(a.groupNames, b.groupNames); + swap(a.projectionSpec, b.projectionSpec); + swap(a.filterSpec, b.filterSpec); + swap(a.processorCapabilities, b.processorCapabilities); + swap(a.processorIdentifier, b.processorIdentifier); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.__isset, b.__isset); +} + +bool GetPartitionsRequest::operator==(const GetPartitionsRequest & rhs) const +{ + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + if (__isset.withAuth != rhs.__isset.withAuth) + return false; + else if (__isset.withAuth && !(withAuth == rhs.withAuth)) + return false; + if (__isset.user != rhs.__isset.user) + return false; + else if (__isset.user && !(user == rhs.user)) + return false; + if (__isset.groupNames != rhs.__isset.groupNames) + return false; + else if (__isset.groupNames && !(groupNames == rhs.groupNames)) + return false; + if (!(projectionSpec == rhs.projectionSpec)) + return false; + if (!(filterSpec == rhs.filterSpec)) + return false; + if (__isset.processorCapabilities != rhs.__isset.processorCapabilities) + return false; + else if (__isset.processorCapabilities && !(processorCapabilities == rhs.processorCapabilities)) + return false; + if (__isset.processorIdentifier != rhs.__isset.processorIdentifier) + return false; + else if (__isset.processorIdentifier && !(processorIdentifier == rhs.processorIdentifier)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + return true; +} + +GetPartitionsRequest::GetPartitionsRequest(const GetPartitionsRequest& other1726) { + catName = other1726.catName; + dbName = other1726.dbName; + tblName = other1726.tblName; + withAuth = other1726.withAuth; + user = other1726.user; + groupNames = other1726.groupNames; + projectionSpec = other1726.projectionSpec; + filterSpec = other1726.filterSpec; + processorCapabilities = other1726.processorCapabilities; + processorIdentifier = other1726.processorIdentifier; + validWriteIdList = other1726.validWriteIdList; + __isset = other1726.__isset; +} +GetPartitionsRequest& GetPartitionsRequest::operator=(const GetPartitionsRequest& other1727) { + catName = other1727.catName; + dbName = other1727.dbName; + tblName = other1727.tblName; + withAuth = other1727.withAuth; + user = other1727.user; + groupNames = other1727.groupNames; + projectionSpec = other1727.projectionSpec; + filterSpec = other1727.filterSpec; + processorCapabilities = other1727.processorCapabilities; + processorIdentifier = other1727.processorIdentifier; + validWriteIdList = other1727.validWriteIdList; + __isset = other1727.__isset; + return *this; +} +void GetPartitionsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetPartitionsRequest("; + out << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "tblName=" << to_string(tblName); + out << ", " << "withAuth="; (__isset.withAuth ? (out << to_string(withAuth)) : (out << "")); + out << ", " << "user="; (__isset.user ? (out << to_string(user)) : (out << "")); + out << ", " << "groupNames="; (__isset.groupNames ? (out << to_string(groupNames)) : (out << "")); + out << ", " << "projectionSpec=" << to_string(projectionSpec); + out << ", " << "filterSpec=" << to_string(filterSpec); + out << ", " << "processorCapabilities="; (__isset.processorCapabilities ? (out << to_string(processorCapabilities)) : (out << "")); + out << ", " << "processorIdentifier="; (__isset.processorIdentifier ? (out << to_string(processorIdentifier)) : (out << "")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ")"; +} + + +GetFieldsRequest::~GetFieldsRequest() noexcept { +} + +GetFieldsRequest::GetFieldsRequest() noexcept + : catName(), + dbName(), + tblName(), + validWriteIdList(), + id(-1LL) { +} + +void GetFieldsRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void GetFieldsRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void GetFieldsRequest::__set_tblName(const std::string& val) { + this->tblName = val; +} + +void GetFieldsRequest::__set_envContext(const EnvironmentContext& val) { + this->envContext = val; +__isset.envContext = true; +} + +void GetFieldsRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void GetFieldsRequest::__set_id(const int64_t val) { + this->id = val; +__isset.id = true; +} +std::ostream& operator<<(std::ostream& out, const GetFieldsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetFieldsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tblName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tblName); + isset_tblName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->envContext.read(iprot); + this->__isset.envContext = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->id); + this->__isset.id = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tblName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetFieldsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetFieldsRequest"); + + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tblName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.envContext) { + xfer += oprot->writeFieldBegin("envContext", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->envContext.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.id) { + xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I64, 6); + xfer += oprot->writeI64(this->id); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetFieldsRequest &a, GetFieldsRequest &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); + swap(a.envContext, b.envContext); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.id, b.id); + swap(a.__isset, b.__isset); +} + +bool GetFieldsRequest::operator==(const GetFieldsRequest & rhs) const +{ + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + if (__isset.envContext != rhs.__isset.envContext) + return false; + else if (__isset.envContext && !(envContext == rhs.envContext)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.id != rhs.__isset.id) + return false; + else if (__isset.id && !(id == rhs.id)) + return false; + return true; +} + +GetFieldsRequest::GetFieldsRequest(const GetFieldsRequest& other1728) { + catName = other1728.catName; + dbName = other1728.dbName; + tblName = other1728.tblName; + envContext = other1728.envContext; + validWriteIdList = other1728.validWriteIdList; + id = other1728.id; + __isset = other1728.__isset; +} +GetFieldsRequest& GetFieldsRequest::operator=(const GetFieldsRequest& other1729) { + catName = other1729.catName; + dbName = other1729.dbName; + tblName = other1729.tblName; + envContext = other1729.envContext; + validWriteIdList = other1729.validWriteIdList; + id = other1729.id; + __isset = other1729.__isset; + return *this; +} +void GetFieldsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetFieldsRequest("; + out << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "tblName=" << to_string(tblName); + out << ", " << "envContext="; (__isset.envContext ? (out << to_string(envContext)) : (out << "")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "id="; (__isset.id ? (out << to_string(id)) : (out << "")); + out << ")"; +} + + +GetFieldsResponse::~GetFieldsResponse() noexcept { +} + +GetFieldsResponse::GetFieldsResponse() noexcept { +} + +void GetFieldsResponse::__set_fields(const std::vector & val) { + this->fields = val; +} +std::ostream& operator<<(std::ostream& out, const GetFieldsResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetFieldsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_fields = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->fields.clear(); + uint32_t _size1730; + ::apache::thrift::protocol::TType _etype1733; + xfer += iprot->readListBegin(_etype1733, _size1730); + this->fields.resize(_size1730); + uint32_t _i1734; + for (_i1734 = 0; _i1734 < _size1730; ++_i1734) + { + xfer += this->fields[_i1734].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_fields = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_fields) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetFieldsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetFieldsResponse"); + + xfer += oprot->writeFieldBegin("fields", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->fields.size())); + std::vector ::const_iterator _iter1735; + for (_iter1735 = this->fields.begin(); _iter1735 != this->fields.end(); ++_iter1735) + { + xfer += (*_iter1735).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetFieldsResponse &a, GetFieldsResponse &b) noexcept { + using ::std::swap; + swap(a.fields, b.fields); +} + +bool GetFieldsResponse::operator==(const GetFieldsResponse & rhs) const +{ + if (!(fields == rhs.fields)) + return false; + return true; +} + +GetFieldsResponse::GetFieldsResponse(const GetFieldsResponse& other1736) { + fields = other1736.fields; +} +GetFieldsResponse& GetFieldsResponse::operator=(const GetFieldsResponse& other1737) { + fields = other1737.fields; + return *this; +} +void GetFieldsResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetFieldsResponse("; + out << "fields=" << to_string(fields); + out << ")"; +} + + +GetSchemaRequest::~GetSchemaRequest() noexcept { +} + +GetSchemaRequest::GetSchemaRequest() noexcept + : catName(), + dbName(), + tblName(), + validWriteIdList(), + id(-1LL) { +} + +void GetSchemaRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void GetSchemaRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void GetSchemaRequest::__set_tblName(const std::string& val) { + this->tblName = val; +} + +void GetSchemaRequest::__set_envContext(const EnvironmentContext& val) { + this->envContext = val; +__isset.envContext = true; +} + +void GetSchemaRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void GetSchemaRequest::__set_id(const int64_t val) { + this->id = val; +__isset.id = true; +} +std::ostream& operator<<(std::ostream& out, const GetSchemaRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetSchemaRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tblName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tblName); + isset_tblName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->envContext.read(iprot); + this->__isset.envContext = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->id); + this->__isset.id = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tblName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetSchemaRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetSchemaRequest"); + + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tblName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.envContext) { + xfer += oprot->writeFieldBegin("envContext", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->envContext.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.id) { + xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I64, 6); + xfer += oprot->writeI64(this->id); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetSchemaRequest &a, GetSchemaRequest &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); + swap(a.envContext, b.envContext); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.id, b.id); + swap(a.__isset, b.__isset); +} + +bool GetSchemaRequest::operator==(const GetSchemaRequest & rhs) const +{ + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + if (__isset.envContext != rhs.__isset.envContext) + return false; + else if (__isset.envContext && !(envContext == rhs.envContext)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.id != rhs.__isset.id) + return false; + else if (__isset.id && !(id == rhs.id)) + return false; + return true; +} + +GetSchemaRequest::GetSchemaRequest(const GetSchemaRequest& other1738) { + catName = other1738.catName; + dbName = other1738.dbName; + tblName = other1738.tblName; + envContext = other1738.envContext; + validWriteIdList = other1738.validWriteIdList; + id = other1738.id; + __isset = other1738.__isset; +} +GetSchemaRequest& GetSchemaRequest::operator=(const GetSchemaRequest& other1739) { + catName = other1739.catName; + dbName = other1739.dbName; + tblName = other1739.tblName; + envContext = other1739.envContext; + validWriteIdList = other1739.validWriteIdList; + id = other1739.id; + __isset = other1739.__isset; + return *this; +} +void GetSchemaRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetSchemaRequest("; + out << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "tblName=" << to_string(tblName); + out << ", " << "envContext="; (__isset.envContext ? (out << to_string(envContext)) : (out << "")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "id="; (__isset.id ? (out << to_string(id)) : (out << "")); + out << ")"; +} + + +GetSchemaResponse::~GetSchemaResponse() noexcept { +} + +GetSchemaResponse::GetSchemaResponse() noexcept { +} + +void GetSchemaResponse::__set_fields(const std::vector & val) { + this->fields = val; +} +std::ostream& operator<<(std::ostream& out, const GetSchemaResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetSchemaResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_fields = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->fields.clear(); + uint32_t _size1740; + ::apache::thrift::protocol::TType _etype1743; + xfer += iprot->readListBegin(_etype1743, _size1740); + this->fields.resize(_size1740); + uint32_t _i1744; + for (_i1744 = 0; _i1744 < _size1740; ++_i1744) + { + xfer += this->fields[_i1744].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_fields = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_fields) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetSchemaResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetSchemaResponse"); + + xfer += oprot->writeFieldBegin("fields", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->fields.size())); + std::vector ::const_iterator _iter1745; + for (_iter1745 = this->fields.begin(); _iter1745 != this->fields.end(); ++_iter1745) + { + xfer += (*_iter1745).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetSchemaResponse &a, GetSchemaResponse &b) noexcept { + using ::std::swap; + swap(a.fields, b.fields); +} + +bool GetSchemaResponse::operator==(const GetSchemaResponse & rhs) const +{ + if (!(fields == rhs.fields)) + return false; + return true; +} + +GetSchemaResponse::GetSchemaResponse(const GetSchemaResponse& other1746) { + fields = other1746.fields; +} +GetSchemaResponse& GetSchemaResponse::operator=(const GetSchemaResponse& other1747) { + fields = other1747.fields; + return *this; +} +void GetSchemaResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetSchemaResponse("; + out << "fields=" << to_string(fields); + out << ")"; +} + + +GetPartitionRequest::~GetPartitionRequest() noexcept { +} + +GetPartitionRequest::GetPartitionRequest() noexcept + : catName(), + dbName(), + tblName(), + validWriteIdList(), + id(-1LL) { +} + +void GetPartitionRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void GetPartitionRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void GetPartitionRequest::__set_tblName(const std::string& val) { + this->tblName = val; +} + +void GetPartitionRequest::__set_partVals(const std::vector & val) { + this->partVals = val; +} + +void GetPartitionRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void GetPartitionRequest::__set_id(const int64_t val) { + this->id = val; +__isset.id = true; +} +std::ostream& operator<<(std::ostream& out, const GetPartitionRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetPartitionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tblName = false; + bool isset_partVals = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tblName); + isset_tblName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partVals.clear(); + uint32_t _size1748; + ::apache::thrift::protocol::TType _etype1751; + xfer += iprot->readListBegin(_etype1751, _size1748); + this->partVals.resize(_size1748); + uint32_t _i1752; + for (_i1752 = 0; _i1752 < _size1748; ++_i1752) + { + xfer += iprot->readString(this->partVals[_i1752]); + } + xfer += iprot->readListEnd(); + } + isset_partVals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->id); + this->__isset.id = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tblName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_partVals) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetPartitionRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetPartitionRequest"); + + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tblName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("partVals", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partVals.size())); + std::vector ::const_iterator _iter1753; + for (_iter1753 = this->partVals.begin(); _iter1753 != this->partVals.end(); ++_iter1753) + { + xfer += oprot->writeString((*_iter1753)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.id) { + xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I64, 6); + xfer += oprot->writeI64(this->id); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetPartitionRequest &a, GetPartitionRequest &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); + swap(a.partVals, b.partVals); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.id, b.id); + swap(a.__isset, b.__isset); +} + +bool GetPartitionRequest::operator==(const GetPartitionRequest & rhs) const +{ + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + if (!(partVals == rhs.partVals)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.id != rhs.__isset.id) + return false; + else if (__isset.id && !(id == rhs.id)) + return false; + return true; +} + +GetPartitionRequest::GetPartitionRequest(const GetPartitionRequest& other1754) { + catName = other1754.catName; + dbName = other1754.dbName; + tblName = other1754.tblName; + partVals = other1754.partVals; + validWriteIdList = other1754.validWriteIdList; + id = other1754.id; + __isset = other1754.__isset; +} +GetPartitionRequest& GetPartitionRequest::operator=(const GetPartitionRequest& other1755) { + catName = other1755.catName; + dbName = other1755.dbName; + tblName = other1755.tblName; + partVals = other1755.partVals; + validWriteIdList = other1755.validWriteIdList; + id = other1755.id; + __isset = other1755.__isset; + return *this; +} +void GetPartitionRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetPartitionRequest("; + out << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "tblName=" << to_string(tblName); + out << ", " << "partVals=" << to_string(partVals); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "id="; (__isset.id ? (out << to_string(id)) : (out << "")); + out << ")"; +} + + +GetPartitionResponse::~GetPartitionResponse() noexcept { +} + +GetPartitionResponse::GetPartitionResponse() noexcept { +} + +void GetPartitionResponse::__set_partition(const Partition& val) { + this->partition = val; +} +std::ostream& operator<<(std::ostream& out, const GetPartitionResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetPartitionResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_partition = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->partition.read(iprot); + isset_partition = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_partition) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetPartitionResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetPartitionResponse"); + + xfer += oprot->writeFieldBegin("partition", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->partition.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetPartitionResponse &a, GetPartitionResponse &b) noexcept { + using ::std::swap; + swap(a.partition, b.partition); +} + +bool GetPartitionResponse::operator==(const GetPartitionResponse & rhs) const +{ + if (!(partition == rhs.partition)) + return false; + return true; +} + +GetPartitionResponse::GetPartitionResponse(const GetPartitionResponse& other1756) { + partition = other1756.partition; +} +GetPartitionResponse& GetPartitionResponse::operator=(const GetPartitionResponse& other1757) { + partition = other1757.partition; + return *this; +} +void GetPartitionResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetPartitionResponse("; + out << "partition=" << to_string(partition); + out << ")"; +} + + +PartitionsRequest::~PartitionsRequest() noexcept { +} + +PartitionsRequest::PartitionsRequest() noexcept + : catName(), + dbName(), + tblName(), + maxParts(-1), + validWriteIdList(), + id(-1LL), + skipColumnSchemaForPartition(0), + includeParamKeyPattern(), + excludeParamKeyPattern() { +} + +void PartitionsRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void PartitionsRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void PartitionsRequest::__set_tblName(const std::string& val) { + this->tblName = val; +} + +void PartitionsRequest::__set_maxParts(const int16_t val) { + this->maxParts = val; +__isset.maxParts = true; +} + +void PartitionsRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void PartitionsRequest::__set_id(const int64_t val) { + this->id = val; +__isset.id = true; +} + +void PartitionsRequest::__set_skipColumnSchemaForPartition(const bool val) { + this->skipColumnSchemaForPartition = val; +__isset.skipColumnSchemaForPartition = true; +} + +void PartitionsRequest::__set_includeParamKeyPattern(const std::string& val) { + this->includeParamKeyPattern = val; +__isset.includeParamKeyPattern = true; +} + +void PartitionsRequest::__set_excludeParamKeyPattern(const std::string& val) { + this->excludeParamKeyPattern = val; +__isset.excludeParamKeyPattern = true; +} +std::ostream& operator<<(std::ostream& out, const PartitionsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PartitionsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tblName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tblName); + isset_tblName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I16) { + xfer += iprot->readI16(this->maxParts); + this->__isset.maxParts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->id); + this->__isset.id = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->skipColumnSchemaForPartition); + this->__isset.skipColumnSchemaForPartition = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->includeParamKeyPattern); + this->__isset.includeParamKeyPattern = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->excludeParamKeyPattern); + this->__isset.excludeParamKeyPattern = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tblName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t PartitionsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PartitionsRequest"); + + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tblName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.maxParts) { + xfer += oprot->writeFieldBegin("maxParts", ::apache::thrift::protocol::T_I16, 4); + xfer += oprot->writeI16(this->maxParts); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.id) { + xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I64, 6); + xfer += oprot->writeI64(this->id); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.skipColumnSchemaForPartition) { + xfer += oprot->writeFieldBegin("skipColumnSchemaForPartition", ::apache::thrift::protocol::T_BOOL, 7); + xfer += oprot->writeBool(this->skipColumnSchemaForPartition); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.includeParamKeyPattern) { + xfer += oprot->writeFieldBegin("includeParamKeyPattern", ::apache::thrift::protocol::T_STRING, 8); + xfer += oprot->writeString(this->includeParamKeyPattern); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.excludeParamKeyPattern) { + xfer += oprot->writeFieldBegin("excludeParamKeyPattern", ::apache::thrift::protocol::T_STRING, 9); + xfer += oprot->writeString(this->excludeParamKeyPattern); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PartitionsRequest &a, PartitionsRequest &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); + swap(a.maxParts, b.maxParts); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.id, b.id); + swap(a.skipColumnSchemaForPartition, b.skipColumnSchemaForPartition); + swap(a.includeParamKeyPattern, b.includeParamKeyPattern); + swap(a.excludeParamKeyPattern, b.excludeParamKeyPattern); + swap(a.__isset, b.__isset); +} + +bool PartitionsRequest::operator==(const PartitionsRequest & rhs) const +{ + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + if (__isset.maxParts != rhs.__isset.maxParts) + return false; + else if (__isset.maxParts && !(maxParts == rhs.maxParts)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.id != rhs.__isset.id) + return false; + else if (__isset.id && !(id == rhs.id)) + return false; + if (__isset.skipColumnSchemaForPartition != rhs.__isset.skipColumnSchemaForPartition) + return false; + else if (__isset.skipColumnSchemaForPartition && !(skipColumnSchemaForPartition == rhs.skipColumnSchemaForPartition)) + return false; + if (__isset.includeParamKeyPattern != rhs.__isset.includeParamKeyPattern) + return false; + else if (__isset.includeParamKeyPattern && !(includeParamKeyPattern == rhs.includeParamKeyPattern)) + return false; + if (__isset.excludeParamKeyPattern != rhs.__isset.excludeParamKeyPattern) + return false; + else if (__isset.excludeParamKeyPattern && !(excludeParamKeyPattern == rhs.excludeParamKeyPattern)) + return false; + return true; +} + +PartitionsRequest::PartitionsRequest(const PartitionsRequest& other1758) { + catName = other1758.catName; + dbName = other1758.dbName; + tblName = other1758.tblName; + maxParts = other1758.maxParts; + validWriteIdList = other1758.validWriteIdList; + id = other1758.id; + skipColumnSchemaForPartition = other1758.skipColumnSchemaForPartition; + includeParamKeyPattern = other1758.includeParamKeyPattern; + excludeParamKeyPattern = other1758.excludeParamKeyPattern; + __isset = other1758.__isset; +} +PartitionsRequest& PartitionsRequest::operator=(const PartitionsRequest& other1759) { + catName = other1759.catName; + dbName = other1759.dbName; + tblName = other1759.tblName; + maxParts = other1759.maxParts; + validWriteIdList = other1759.validWriteIdList; + id = other1759.id; + skipColumnSchemaForPartition = other1759.skipColumnSchemaForPartition; + includeParamKeyPattern = other1759.includeParamKeyPattern; + excludeParamKeyPattern = other1759.excludeParamKeyPattern; + __isset = other1759.__isset; + return *this; +} +void PartitionsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PartitionsRequest("; + out << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "tblName=" << to_string(tblName); + out << ", " << "maxParts="; (__isset.maxParts ? (out << to_string(maxParts)) : (out << "")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "id="; (__isset.id ? (out << to_string(id)) : (out << "")); + out << ", " << "skipColumnSchemaForPartition="; (__isset.skipColumnSchemaForPartition ? (out << to_string(skipColumnSchemaForPartition)) : (out << "")); + out << ", " << "includeParamKeyPattern="; (__isset.includeParamKeyPattern ? (out << to_string(includeParamKeyPattern)) : (out << "")); + out << ", " << "excludeParamKeyPattern="; (__isset.excludeParamKeyPattern ? (out << to_string(excludeParamKeyPattern)) : (out << "")); + out << ")"; +} + + +PartitionsResponse::~PartitionsResponse() noexcept { +} + +PartitionsResponse::PartitionsResponse() noexcept { +} + +void PartitionsResponse::__set_partitions(const std::vector & val) { + this->partitions = val; +} +std::ostream& operator<<(std::ostream& out, const PartitionsResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PartitionsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_partitions = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitions.clear(); + uint32_t _size1760; + ::apache::thrift::protocol::TType _etype1763; + xfer += iprot->readListBegin(_etype1763, _size1760); + this->partitions.resize(_size1760); + uint32_t _i1764; + for (_i1764 = 0; _i1764 < _size1760; ++_i1764) + { + xfer += this->partitions[_i1764].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_partitions = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_partitions) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t PartitionsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PartitionsResponse"); + + xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); + std::vector ::const_iterator _iter1765; + for (_iter1765 = this->partitions.begin(); _iter1765 != this->partitions.end(); ++_iter1765) + { + xfer += (*_iter1765).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PartitionsResponse &a, PartitionsResponse &b) noexcept { + using ::std::swap; + swap(a.partitions, b.partitions); +} + +bool PartitionsResponse::operator==(const PartitionsResponse & rhs) const +{ + if (!(partitions == rhs.partitions)) + return false; + return true; +} + +PartitionsResponse::PartitionsResponse(const PartitionsResponse& other1766) { + partitions = other1766.partitions; +} +PartitionsResponse& PartitionsResponse::operator=(const PartitionsResponse& other1767) { + partitions = other1767.partitions; + return *this; +} +void PartitionsResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PartitionsResponse("; + out << "partitions=" << to_string(partitions); + out << ")"; +} + + +GetPartitionsByFilterRequest::~GetPartitionsByFilterRequest() noexcept { +} + +GetPartitionsByFilterRequest::GetPartitionsByFilterRequest() noexcept + : catName(), + dbName(), + tblName(), + filter(), + maxParts(-1), + skipColumnSchemaForPartition(0), + includeParamKeyPattern(), + excludeParamKeyPattern() { +} + +void GetPartitionsByFilterRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void GetPartitionsByFilterRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void GetPartitionsByFilterRequest::__set_tblName(const std::string& val) { + this->tblName = val; +} + +void GetPartitionsByFilterRequest::__set_filter(const std::string& val) { + this->filter = val; +} + +void GetPartitionsByFilterRequest::__set_maxParts(const int16_t val) { + this->maxParts = val; +__isset.maxParts = true; +} + +void GetPartitionsByFilterRequest::__set_skipColumnSchemaForPartition(const bool val) { + this->skipColumnSchemaForPartition = val; +__isset.skipColumnSchemaForPartition = true; +} + +void GetPartitionsByFilterRequest::__set_includeParamKeyPattern(const std::string& val) { + this->includeParamKeyPattern = val; +__isset.includeParamKeyPattern = true; +} + +void GetPartitionsByFilterRequest::__set_excludeParamKeyPattern(const std::string& val) { + this->excludeParamKeyPattern = val; +__isset.excludeParamKeyPattern = true; +} +std::ostream& operator<<(std::ostream& out, const GetPartitionsByFilterRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetPartitionsByFilterRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tblName); + this->__isset.tblName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->filter); + this->__isset.filter = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I16) { + xfer += iprot->readI16(this->maxParts); + this->__isset.maxParts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->skipColumnSchemaForPartition); + this->__isset.skipColumnSchemaForPartition = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->includeParamKeyPattern); + this->__isset.includeParamKeyPattern = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->excludeParamKeyPattern); + this->__isset.excludeParamKeyPattern = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t GetPartitionsByFilterRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetPartitionsByFilterRequest"); + + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tblName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("filter", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->filter); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.maxParts) { + xfer += oprot->writeFieldBegin("maxParts", ::apache::thrift::protocol::T_I16, 5); + xfer += oprot->writeI16(this->maxParts); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.skipColumnSchemaForPartition) { + xfer += oprot->writeFieldBegin("skipColumnSchemaForPartition", ::apache::thrift::protocol::T_BOOL, 6); + xfer += oprot->writeBool(this->skipColumnSchemaForPartition); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.includeParamKeyPattern) { + xfer += oprot->writeFieldBegin("includeParamKeyPattern", ::apache::thrift::protocol::T_STRING, 7); + xfer += oprot->writeString(this->includeParamKeyPattern); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.excludeParamKeyPattern) { + xfer += oprot->writeFieldBegin("excludeParamKeyPattern", ::apache::thrift::protocol::T_STRING, 8); + xfer += oprot->writeString(this->excludeParamKeyPattern); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetPartitionsByFilterRequest &a, GetPartitionsByFilterRequest &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); + swap(a.filter, b.filter); + swap(a.maxParts, b.maxParts); + swap(a.skipColumnSchemaForPartition, b.skipColumnSchemaForPartition); + swap(a.includeParamKeyPattern, b.includeParamKeyPattern); + swap(a.excludeParamKeyPattern, b.excludeParamKeyPattern); + swap(a.__isset, b.__isset); +} + +bool GetPartitionsByFilterRequest::operator==(const GetPartitionsByFilterRequest & rhs) const +{ + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + if (!(filter == rhs.filter)) + return false; + if (__isset.maxParts != rhs.__isset.maxParts) + return false; + else if (__isset.maxParts && !(maxParts == rhs.maxParts)) + return false; + if (__isset.skipColumnSchemaForPartition != rhs.__isset.skipColumnSchemaForPartition) + return false; + else if (__isset.skipColumnSchemaForPartition && !(skipColumnSchemaForPartition == rhs.skipColumnSchemaForPartition)) + return false; + if (__isset.includeParamKeyPattern != rhs.__isset.includeParamKeyPattern) + return false; + else if (__isset.includeParamKeyPattern && !(includeParamKeyPattern == rhs.includeParamKeyPattern)) + return false; + if (__isset.excludeParamKeyPattern != rhs.__isset.excludeParamKeyPattern) + return false; + else if (__isset.excludeParamKeyPattern && !(excludeParamKeyPattern == rhs.excludeParamKeyPattern)) + return false; + return true; +} + +GetPartitionsByFilterRequest::GetPartitionsByFilterRequest(const GetPartitionsByFilterRequest& other1768) { + catName = other1768.catName; + dbName = other1768.dbName; + tblName = other1768.tblName; + filter = other1768.filter; + maxParts = other1768.maxParts; + skipColumnSchemaForPartition = other1768.skipColumnSchemaForPartition; + includeParamKeyPattern = other1768.includeParamKeyPattern; + excludeParamKeyPattern = other1768.excludeParamKeyPattern; + __isset = other1768.__isset; +} +GetPartitionsByFilterRequest& GetPartitionsByFilterRequest::operator=(const GetPartitionsByFilterRequest& other1769) { + catName = other1769.catName; + dbName = other1769.dbName; + tblName = other1769.tblName; + filter = other1769.filter; + maxParts = other1769.maxParts; + skipColumnSchemaForPartition = other1769.skipColumnSchemaForPartition; + includeParamKeyPattern = other1769.includeParamKeyPattern; + excludeParamKeyPattern = other1769.excludeParamKeyPattern; + __isset = other1769.__isset; + return *this; +} +void GetPartitionsByFilterRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetPartitionsByFilterRequest("; + out << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "tblName=" << to_string(tblName); + out << ", " << "filter=" << to_string(filter); + out << ", " << "maxParts="; (__isset.maxParts ? (out << to_string(maxParts)) : (out << "")); + out << ", " << "skipColumnSchemaForPartition="; (__isset.skipColumnSchemaForPartition ? (out << to_string(skipColumnSchemaForPartition)) : (out << "")); + out << ", " << "includeParamKeyPattern="; (__isset.includeParamKeyPattern ? (out << to_string(includeParamKeyPattern)) : (out << "")); + out << ", " << "excludeParamKeyPattern="; (__isset.excludeParamKeyPattern ? (out << to_string(excludeParamKeyPattern)) : (out << "")); + out << ")"; +} + + +GetPartitionNamesPsRequest::~GetPartitionNamesPsRequest() noexcept { +} + +GetPartitionNamesPsRequest::GetPartitionNamesPsRequest() noexcept + : catName(), + dbName(), + tblName(), + maxParts(-1), + validWriteIdList(), + id(-1LL) { +} + +void GetPartitionNamesPsRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void GetPartitionNamesPsRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void GetPartitionNamesPsRequest::__set_tblName(const std::string& val) { + this->tblName = val; +} + +void GetPartitionNamesPsRequest::__set_partValues(const std::vector & val) { + this->partValues = val; +__isset.partValues = true; +} + +void GetPartitionNamesPsRequest::__set_maxParts(const int16_t val) { + this->maxParts = val; +__isset.maxParts = true; +} + +void GetPartitionNamesPsRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void GetPartitionNamesPsRequest::__set_id(const int64_t val) { + this->id = val; +__isset.id = true; +} +std::ostream& operator<<(std::ostream& out, const GetPartitionNamesPsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetPartitionNamesPsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tblName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tblName); + isset_tblName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partValues.clear(); + uint32_t _size1770; + ::apache::thrift::protocol::TType _etype1773; + xfer += iprot->readListBegin(_etype1773, _size1770); + this->partValues.resize(_size1770); + uint32_t _i1774; + for (_i1774 = 0; _i1774 < _size1770; ++_i1774) + { + xfer += iprot->readString(this->partValues[_i1774]); + } + xfer += iprot->readListEnd(); + } + this->__isset.partValues = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I16) { + xfer += iprot->readI16(this->maxParts); + this->__isset.maxParts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->id); + this->__isset.id = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tblName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetPartitionNamesPsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetPartitionNamesPsRequest"); + + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tblName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.partValues) { + xfer += oprot->writeFieldBegin("partValues", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partValues.size())); + std::vector ::const_iterator _iter1775; + for (_iter1775 = this->partValues.begin(); _iter1775 != this->partValues.end(); ++_iter1775) + { + xfer += oprot->writeString((*_iter1775)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.maxParts) { + xfer += oprot->writeFieldBegin("maxParts", ::apache::thrift::protocol::T_I16, 5); + xfer += oprot->writeI16(this->maxParts); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.id) { + xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I64, 7); + xfer += oprot->writeI64(this->id); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetPartitionNamesPsRequest &a, GetPartitionNamesPsRequest &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); + swap(a.partValues, b.partValues); + swap(a.maxParts, b.maxParts); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.id, b.id); + swap(a.__isset, b.__isset); +} + +bool GetPartitionNamesPsRequest::operator==(const GetPartitionNamesPsRequest & rhs) const +{ + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + if (__isset.partValues != rhs.__isset.partValues) + return false; + else if (__isset.partValues && !(partValues == rhs.partValues)) + return false; + if (__isset.maxParts != rhs.__isset.maxParts) + return false; + else if (__isset.maxParts && !(maxParts == rhs.maxParts)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.id != rhs.__isset.id) + return false; + else if (__isset.id && !(id == rhs.id)) + return false; + return true; +} + +GetPartitionNamesPsRequest::GetPartitionNamesPsRequest(const GetPartitionNamesPsRequest& other1776) { + catName = other1776.catName; + dbName = other1776.dbName; + tblName = other1776.tblName; + partValues = other1776.partValues; + maxParts = other1776.maxParts; + validWriteIdList = other1776.validWriteIdList; + id = other1776.id; + __isset = other1776.__isset; +} +GetPartitionNamesPsRequest& GetPartitionNamesPsRequest::operator=(const GetPartitionNamesPsRequest& other1777) { + catName = other1777.catName; + dbName = other1777.dbName; + tblName = other1777.tblName; + partValues = other1777.partValues; + maxParts = other1777.maxParts; + validWriteIdList = other1777.validWriteIdList; + id = other1777.id; + __isset = other1777.__isset; + return *this; +} +void GetPartitionNamesPsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetPartitionNamesPsRequest("; + out << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "tblName=" << to_string(tblName); + out << ", " << "partValues="; (__isset.partValues ? (out << to_string(partValues)) : (out << "")); + out << ", " << "maxParts="; (__isset.maxParts ? (out << to_string(maxParts)) : (out << "")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "id="; (__isset.id ? (out << to_string(id)) : (out << "")); + out << ")"; +} + + +GetPartitionNamesPsResponse::~GetPartitionNamesPsResponse() noexcept { +} + +GetPartitionNamesPsResponse::GetPartitionNamesPsResponse() noexcept { +} + +void GetPartitionNamesPsResponse::__set_names(const std::vector & val) { + this->names = val; +} +std::ostream& operator<<(std::ostream& out, const GetPartitionNamesPsResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetPartitionNamesPsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_names = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->names.clear(); + uint32_t _size1778; + ::apache::thrift::protocol::TType _etype1781; + xfer += iprot->readListBegin(_etype1781, _size1778); + this->names.resize(_size1778); + uint32_t _i1782; + for (_i1782 = 0; _i1782 < _size1778; ++_i1782) + { + xfer += iprot->readString(this->names[_i1782]); + } + xfer += iprot->readListEnd(); + } + isset_names = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_names) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetPartitionNamesPsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetPartitionNamesPsResponse"); + + xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->names.size())); + std::vector ::const_iterator _iter1783; + for (_iter1783 = this->names.begin(); _iter1783 != this->names.end(); ++_iter1783) + { + xfer += oprot->writeString((*_iter1783)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetPartitionNamesPsResponse &a, GetPartitionNamesPsResponse &b) noexcept { + using ::std::swap; + swap(a.names, b.names); +} + +bool GetPartitionNamesPsResponse::operator==(const GetPartitionNamesPsResponse & rhs) const +{ + if (!(names == rhs.names)) + return false; + return true; +} + +GetPartitionNamesPsResponse::GetPartitionNamesPsResponse(const GetPartitionNamesPsResponse& other1784) { + names = other1784.names; +} +GetPartitionNamesPsResponse& GetPartitionNamesPsResponse::operator=(const GetPartitionNamesPsResponse& other1785) { + names = other1785.names; + return *this; +} +void GetPartitionNamesPsResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetPartitionNamesPsResponse("; + out << "names=" << to_string(names); + out << ")"; +} + + +GetPartitionsPsWithAuthRequest::~GetPartitionsPsWithAuthRequest() noexcept { +} + +GetPartitionsPsWithAuthRequest::GetPartitionsPsWithAuthRequest() noexcept + : catName(), + dbName(), + tblName(), + maxParts(-1), + userName(), + validWriteIdList(), + id(-1LL), + skipColumnSchemaForPartition(0), + includeParamKeyPattern(), + excludeParamKeyPattern() { +} + +void GetPartitionsPsWithAuthRequest::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + +void GetPartitionsPsWithAuthRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void GetPartitionsPsWithAuthRequest::__set_tblName(const std::string& val) { + this->tblName = val; +} + +void GetPartitionsPsWithAuthRequest::__set_partVals(const std::vector & val) { + this->partVals = val; +__isset.partVals = true; +} + +void GetPartitionsPsWithAuthRequest::__set_maxParts(const int16_t val) { + this->maxParts = val; +__isset.maxParts = true; +} + +void GetPartitionsPsWithAuthRequest::__set_userName(const std::string& val) { + this->userName = val; +__isset.userName = true; +} + +void GetPartitionsPsWithAuthRequest::__set_groupNames(const std::vector & val) { + this->groupNames = val; +__isset.groupNames = true; +} + +void GetPartitionsPsWithAuthRequest::__set_validWriteIdList(const std::string& val) { + this->validWriteIdList = val; +__isset.validWriteIdList = true; +} + +void GetPartitionsPsWithAuthRequest::__set_id(const int64_t val) { + this->id = val; +__isset.id = true; +} + +void GetPartitionsPsWithAuthRequest::__set_skipColumnSchemaForPartition(const bool val) { + this->skipColumnSchemaForPartition = val; +__isset.skipColumnSchemaForPartition = true; +} + +void GetPartitionsPsWithAuthRequest::__set_includeParamKeyPattern(const std::string& val) { + this->includeParamKeyPattern = val; +__isset.includeParamKeyPattern = true; +} + +void GetPartitionsPsWithAuthRequest::__set_excludeParamKeyPattern(const std::string& val) { + this->excludeParamKeyPattern = val; +__isset.excludeParamKeyPattern = true; +} + +void GetPartitionsPsWithAuthRequest::__set_partNames(const std::vector & val) { + this->partNames = val; +__isset.partNames = true; +} +std::ostream& operator<<(std::ostream& out, const GetPartitionsPsWithAuthRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetPartitionsPsWithAuthRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tblName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tblName); + isset_tblName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partVals.clear(); + uint32_t _size1786; + ::apache::thrift::protocol::TType _etype1789; + xfer += iprot->readListBegin(_etype1789, _size1786); + this->partVals.resize(_size1786); + uint32_t _i1790; + for (_i1790 = 0; _i1790 < _size1786; ++_i1790) + { + xfer += iprot->readString(this->partVals[_i1790]); + } + xfer += iprot->readListEnd(); + } + this->__isset.partVals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I16) { + xfer += iprot->readI16(this->maxParts); + this->__isset.maxParts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->userName); + this->__isset.userName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->groupNames.clear(); + uint32_t _size1791; + ::apache::thrift::protocol::TType _etype1794; + xfer += iprot->readListBegin(_etype1794, _size1791); + this->groupNames.resize(_size1791); + uint32_t _i1795; + for (_i1795 = 0; _i1795 < _size1791; ++_i1795) + { + xfer += iprot->readString(this->groupNames[_i1795]); + } + xfer += iprot->readListEnd(); + } + this->__isset.groupNames = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validWriteIdList); + this->__isset.validWriteIdList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->id); + this->__isset.id = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->skipColumnSchemaForPartition); + this->__isset.skipColumnSchemaForPartition = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 11: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->includeParamKeyPattern); + this->__isset.includeParamKeyPattern = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 12: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->excludeParamKeyPattern); + this->__isset.excludeParamKeyPattern = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 13: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partNames.clear(); + uint32_t _size1796; + ::apache::thrift::protocol::TType _etype1799; + xfer += iprot->readListBegin(_etype1799, _size1796); + this->partNames.resize(_size1796); + uint32_t _i1800; + for (_i1800 = 0; _i1800 < _size1796; ++_i1800) + { + xfer += iprot->readString(this->partNames[_i1800]); + } + xfer += iprot->readListEnd(); + } + this->__isset.partNames = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tblName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetPartitionsPsWithAuthRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetPartitionsPsWithAuthRequest"); + + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tblName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.partVals) { + xfer += oprot->writeFieldBegin("partVals", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partVals.size())); + std::vector ::const_iterator _iter1801; + for (_iter1801 = this->partVals.begin(); _iter1801 != this->partVals.end(); ++_iter1801) + { + xfer += oprot->writeString((*_iter1801)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.maxParts) { + xfer += oprot->writeFieldBegin("maxParts", ::apache::thrift::protocol::T_I16, 5); + xfer += oprot->writeI16(this->maxParts); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.userName) { + xfer += oprot->writeFieldBegin("userName", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->userName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.groupNames) { + xfer += oprot->writeFieldBegin("groupNames", ::apache::thrift::protocol::T_LIST, 7); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->groupNames.size())); + std::vector ::const_iterator _iter1802; + for (_iter1802 = this->groupNames.begin(); _iter1802 != this->groupNames.end(); ++_iter1802) + { + xfer += oprot->writeString((*_iter1802)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.validWriteIdList) { + xfer += oprot->writeFieldBegin("validWriteIdList", ::apache::thrift::protocol::T_STRING, 8); + xfer += oprot->writeString(this->validWriteIdList); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.id) { + xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I64, 9); + xfer += oprot->writeI64(this->id); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.skipColumnSchemaForPartition) { + xfer += oprot->writeFieldBegin("skipColumnSchemaForPartition", ::apache::thrift::protocol::T_BOOL, 10); + xfer += oprot->writeBool(this->skipColumnSchemaForPartition); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.includeParamKeyPattern) { + xfer += oprot->writeFieldBegin("includeParamKeyPattern", ::apache::thrift::protocol::T_STRING, 11); + xfer += oprot->writeString(this->includeParamKeyPattern); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.excludeParamKeyPattern) { + xfer += oprot->writeFieldBegin("excludeParamKeyPattern", ::apache::thrift::protocol::T_STRING, 12); + xfer += oprot->writeString(this->excludeParamKeyPattern); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.partNames) { + xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 13); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partNames.size())); + std::vector ::const_iterator _iter1803; + for (_iter1803 = this->partNames.begin(); _iter1803 != this->partNames.end(); ++_iter1803) + { + xfer += oprot->writeString((*_iter1803)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetPartitionsPsWithAuthRequest &a, GetPartitionsPsWithAuthRequest &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); + swap(a.partVals, b.partVals); + swap(a.maxParts, b.maxParts); + swap(a.userName, b.userName); + swap(a.groupNames, b.groupNames); + swap(a.validWriteIdList, b.validWriteIdList); + swap(a.id, b.id); + swap(a.skipColumnSchemaForPartition, b.skipColumnSchemaForPartition); + swap(a.includeParamKeyPattern, b.includeParamKeyPattern); + swap(a.excludeParamKeyPattern, b.excludeParamKeyPattern); + swap(a.partNames, b.partNames); + swap(a.__isset, b.__isset); +} + +bool GetPartitionsPsWithAuthRequest::operator==(const GetPartitionsPsWithAuthRequest & rhs) const +{ + if (__isset.catName != rhs.__isset.catName) + return false; + else if (__isset.catName && !(catName == rhs.catName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + if (__isset.partVals != rhs.__isset.partVals) + return false; + else if (__isset.partVals && !(partVals == rhs.partVals)) + return false; + if (__isset.maxParts != rhs.__isset.maxParts) + return false; + else if (__isset.maxParts && !(maxParts == rhs.maxParts)) + return false; + if (__isset.userName != rhs.__isset.userName) + return false; + else if (__isset.userName && !(userName == rhs.userName)) + return false; + if (__isset.groupNames != rhs.__isset.groupNames) + return false; + else if (__isset.groupNames && !(groupNames == rhs.groupNames)) + return false; + if (__isset.validWriteIdList != rhs.__isset.validWriteIdList) + return false; + else if (__isset.validWriteIdList && !(validWriteIdList == rhs.validWriteIdList)) + return false; + if (__isset.id != rhs.__isset.id) + return false; + else if (__isset.id && !(id == rhs.id)) + return false; + if (__isset.skipColumnSchemaForPartition != rhs.__isset.skipColumnSchemaForPartition) + return false; + else if (__isset.skipColumnSchemaForPartition && !(skipColumnSchemaForPartition == rhs.skipColumnSchemaForPartition)) + return false; + if (__isset.includeParamKeyPattern != rhs.__isset.includeParamKeyPattern) + return false; + else if (__isset.includeParamKeyPattern && !(includeParamKeyPattern == rhs.includeParamKeyPattern)) + return false; + if (__isset.excludeParamKeyPattern != rhs.__isset.excludeParamKeyPattern) + return false; + else if (__isset.excludeParamKeyPattern && !(excludeParamKeyPattern == rhs.excludeParamKeyPattern)) + return false; + if (__isset.partNames != rhs.__isset.partNames) + return false; + else if (__isset.partNames && !(partNames == rhs.partNames)) + return false; + return true; +} + +GetPartitionsPsWithAuthRequest::GetPartitionsPsWithAuthRequest(const GetPartitionsPsWithAuthRequest& other1804) { + catName = other1804.catName; + dbName = other1804.dbName; + tblName = other1804.tblName; + partVals = other1804.partVals; + maxParts = other1804.maxParts; + userName = other1804.userName; + groupNames = other1804.groupNames; + validWriteIdList = other1804.validWriteIdList; + id = other1804.id; + skipColumnSchemaForPartition = other1804.skipColumnSchemaForPartition; + includeParamKeyPattern = other1804.includeParamKeyPattern; + excludeParamKeyPattern = other1804.excludeParamKeyPattern; + partNames = other1804.partNames; + __isset = other1804.__isset; +} +GetPartitionsPsWithAuthRequest& GetPartitionsPsWithAuthRequest::operator=(const GetPartitionsPsWithAuthRequest& other1805) { + catName = other1805.catName; + dbName = other1805.dbName; + tblName = other1805.tblName; + partVals = other1805.partVals; + maxParts = other1805.maxParts; + userName = other1805.userName; + groupNames = other1805.groupNames; + validWriteIdList = other1805.validWriteIdList; + id = other1805.id; + skipColumnSchemaForPartition = other1805.skipColumnSchemaForPartition; + includeParamKeyPattern = other1805.includeParamKeyPattern; + excludeParamKeyPattern = other1805.excludeParamKeyPattern; + partNames = other1805.partNames; + __isset = other1805.__isset; + return *this; +} +void GetPartitionsPsWithAuthRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetPartitionsPsWithAuthRequest("; + out << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "tblName=" << to_string(tblName); + out << ", " << "partVals="; (__isset.partVals ? (out << to_string(partVals)) : (out << "")); + out << ", " << "maxParts="; (__isset.maxParts ? (out << to_string(maxParts)) : (out << "")); + out << ", " << "userName="; (__isset.userName ? (out << to_string(userName)) : (out << "")); + out << ", " << "groupNames="; (__isset.groupNames ? (out << to_string(groupNames)) : (out << "")); + out << ", " << "validWriteIdList="; (__isset.validWriteIdList ? (out << to_string(validWriteIdList)) : (out << "")); + out << ", " << "id="; (__isset.id ? (out << to_string(id)) : (out << "")); + out << ", " << "skipColumnSchemaForPartition="; (__isset.skipColumnSchemaForPartition ? (out << to_string(skipColumnSchemaForPartition)) : (out << "")); + out << ", " << "includeParamKeyPattern="; (__isset.includeParamKeyPattern ? (out << to_string(includeParamKeyPattern)) : (out << "")); + out << ", " << "excludeParamKeyPattern="; (__isset.excludeParamKeyPattern ? (out << to_string(excludeParamKeyPattern)) : (out << "")); + out << ", " << "partNames="; (__isset.partNames ? (out << to_string(partNames)) : (out << "")); + out << ")"; +} + + +GetPartitionsPsWithAuthResponse::~GetPartitionsPsWithAuthResponse() noexcept { +} + +GetPartitionsPsWithAuthResponse::GetPartitionsPsWithAuthResponse() noexcept { +} + +void GetPartitionsPsWithAuthResponse::__set_partitions(const std::vector & val) { + this->partitions = val; +} +std::ostream& operator<<(std::ostream& out, const GetPartitionsPsWithAuthResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetPartitionsPsWithAuthResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_partitions = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitions.clear(); + uint32_t _size1806; + ::apache::thrift::protocol::TType _etype1809; + xfer += iprot->readListBegin(_etype1809, _size1806); + this->partitions.resize(_size1806); + uint32_t _i1810; + for (_i1810 = 0; _i1810 < _size1806; ++_i1810) + { + xfer += this->partitions[_i1810].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_partitions = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_partitions) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetPartitionsPsWithAuthResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetPartitionsPsWithAuthResponse"); + + xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); + std::vector ::const_iterator _iter1811; + for (_iter1811 = this->partitions.begin(); _iter1811 != this->partitions.end(); ++_iter1811) + { + xfer += (*_iter1811).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetPartitionsPsWithAuthResponse &a, GetPartitionsPsWithAuthResponse &b) noexcept { + using ::std::swap; + swap(a.partitions, b.partitions); +} + +bool GetPartitionsPsWithAuthResponse::operator==(const GetPartitionsPsWithAuthResponse & rhs) const +{ + if (!(partitions == rhs.partitions)) + return false; + return true; +} + +GetPartitionsPsWithAuthResponse::GetPartitionsPsWithAuthResponse(const GetPartitionsPsWithAuthResponse& other1812) { + partitions = other1812.partitions; +} +GetPartitionsPsWithAuthResponse& GetPartitionsPsWithAuthResponse::operator=(const GetPartitionsPsWithAuthResponse& other1813) { + partitions = other1813.partitions; + return *this; +} +void GetPartitionsPsWithAuthResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetPartitionsPsWithAuthResponse("; + out << "partitions=" << to_string(partitions); + out << ")"; +} + + +ReplicationMetrics::~ReplicationMetrics() noexcept { +} + +ReplicationMetrics::ReplicationMetrics() noexcept + : scheduledExecutionId(0), + policy(), + dumpExecutionId(0), + metadata(), + progress(), + messageFormat() { +} + +void ReplicationMetrics::__set_scheduledExecutionId(const int64_t val) { + this->scheduledExecutionId = val; +} + +void ReplicationMetrics::__set_policy(const std::string& val) { + this->policy = val; +} + +void ReplicationMetrics::__set_dumpExecutionId(const int64_t val) { + this->dumpExecutionId = val; +} + +void ReplicationMetrics::__set_metadata(const std::string& val) { + this->metadata = val; +__isset.metadata = true; +} + +void ReplicationMetrics::__set_progress(const std::string& val) { + this->progress = val; +__isset.progress = true; +} + +void ReplicationMetrics::__set_messageFormat(const std::string& val) { + this->messageFormat = val; +__isset.messageFormat = true; +} +std::ostream& operator<<(std::ostream& out, const ReplicationMetrics& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ReplicationMetrics::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_scheduledExecutionId = false; + bool isset_policy = false; + bool isset_dumpExecutionId = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->scheduledExecutionId); + isset_scheduledExecutionId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->policy); + isset_policy = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->dumpExecutionId); + isset_dumpExecutionId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->metadata); + this->__isset.metadata = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->progress); + this->__isset.progress = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->messageFormat); + this->__isset.messageFormat = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_scheduledExecutionId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_policy) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_dumpExecutionId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ReplicationMetrics::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ReplicationMetrics"); + + xfer += oprot->writeFieldBegin("scheduledExecutionId", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->scheduledExecutionId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("policy", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->policy); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dumpExecutionId", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->dumpExecutionId); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.metadata) { + xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->metadata); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.progress) { + xfer += oprot->writeFieldBegin("progress", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->progress); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.messageFormat) { + xfer += oprot->writeFieldBegin("messageFormat", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->messageFormat); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ReplicationMetrics &a, ReplicationMetrics &b) noexcept { + using ::std::swap; + swap(a.scheduledExecutionId, b.scheduledExecutionId); + swap(a.policy, b.policy); + swap(a.dumpExecutionId, b.dumpExecutionId); + swap(a.metadata, b.metadata); + swap(a.progress, b.progress); + swap(a.messageFormat, b.messageFormat); + swap(a.__isset, b.__isset); +} + +bool ReplicationMetrics::operator==(const ReplicationMetrics & rhs) const +{ + if (!(scheduledExecutionId == rhs.scheduledExecutionId)) + return false; + if (!(policy == rhs.policy)) + return false; + if (!(dumpExecutionId == rhs.dumpExecutionId)) + return false; + if (__isset.metadata != rhs.__isset.metadata) + return false; + else if (__isset.metadata && !(metadata == rhs.metadata)) + return false; + if (__isset.progress != rhs.__isset.progress) + return false; + else if (__isset.progress && !(progress == rhs.progress)) + return false; + if (__isset.messageFormat != rhs.__isset.messageFormat) + return false; + else if (__isset.messageFormat && !(messageFormat == rhs.messageFormat)) + return false; + return true; +} + +ReplicationMetrics::ReplicationMetrics(const ReplicationMetrics& other1814) { + scheduledExecutionId = other1814.scheduledExecutionId; + policy = other1814.policy; + dumpExecutionId = other1814.dumpExecutionId; + metadata = other1814.metadata; + progress = other1814.progress; + messageFormat = other1814.messageFormat; + __isset = other1814.__isset; +} +ReplicationMetrics& ReplicationMetrics::operator=(const ReplicationMetrics& other1815) { + scheduledExecutionId = other1815.scheduledExecutionId; + policy = other1815.policy; + dumpExecutionId = other1815.dumpExecutionId; + metadata = other1815.metadata; + progress = other1815.progress; + messageFormat = other1815.messageFormat; + __isset = other1815.__isset; + return *this; +} +void ReplicationMetrics::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ReplicationMetrics("; + out << "scheduledExecutionId=" << to_string(scheduledExecutionId); + out << ", " << "policy=" << to_string(policy); + out << ", " << "dumpExecutionId=" << to_string(dumpExecutionId); + out << ", " << "metadata="; (__isset.metadata ? (out << to_string(metadata)) : (out << "")); + out << ", " << "progress="; (__isset.progress ? (out << to_string(progress)) : (out << "")); + out << ", " << "messageFormat="; (__isset.messageFormat ? (out << to_string(messageFormat)) : (out << "")); + out << ")"; +} + + +ReplicationMetricList::~ReplicationMetricList() noexcept { +} + +ReplicationMetricList::ReplicationMetricList() noexcept { +} + +void ReplicationMetricList::__set_replicationMetricList(const std::vector & val) { + this->replicationMetricList = val; +} +std::ostream& operator<<(std::ostream& out, const ReplicationMetricList& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ReplicationMetricList::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_replicationMetricList = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->replicationMetricList.clear(); + uint32_t _size1816; + ::apache::thrift::protocol::TType _etype1819; + xfer += iprot->readListBegin(_etype1819, _size1816); + this->replicationMetricList.resize(_size1816); + uint32_t _i1820; + for (_i1820 = 0; _i1820 < _size1816; ++_i1820) + { + xfer += this->replicationMetricList[_i1820].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_replicationMetricList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_replicationMetricList) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ReplicationMetricList::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ReplicationMetricList"); + + xfer += oprot->writeFieldBegin("replicationMetricList", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->replicationMetricList.size())); + std::vector ::const_iterator _iter1821; + for (_iter1821 = this->replicationMetricList.begin(); _iter1821 != this->replicationMetricList.end(); ++_iter1821) + { + xfer += (*_iter1821).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ReplicationMetricList &a, ReplicationMetricList &b) noexcept { + using ::std::swap; + swap(a.replicationMetricList, b.replicationMetricList); +} + +bool ReplicationMetricList::operator==(const ReplicationMetricList & rhs) const +{ + if (!(replicationMetricList == rhs.replicationMetricList)) + return false; + return true; +} + +ReplicationMetricList::ReplicationMetricList(const ReplicationMetricList& other1822) { + replicationMetricList = other1822.replicationMetricList; +} +ReplicationMetricList& ReplicationMetricList::operator=(const ReplicationMetricList& other1823) { + replicationMetricList = other1823.replicationMetricList; + return *this; +} +void ReplicationMetricList::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ReplicationMetricList("; + out << "replicationMetricList=" << to_string(replicationMetricList); + out << ")"; +} + + +GetReplicationMetricsRequest::~GetReplicationMetricsRequest() noexcept { +} + +GetReplicationMetricsRequest::GetReplicationMetricsRequest() noexcept + : scheduledExecutionId(0), + policy(), + dumpExecutionId(0) { +} + +void GetReplicationMetricsRequest::__set_scheduledExecutionId(const int64_t val) { + this->scheduledExecutionId = val; +__isset.scheduledExecutionId = true; +} + +void GetReplicationMetricsRequest::__set_policy(const std::string& val) { + this->policy = val; +__isset.policy = true; +} + +void GetReplicationMetricsRequest::__set_dumpExecutionId(const int64_t val) { + this->dumpExecutionId = val; +__isset.dumpExecutionId = true; +} +std::ostream& operator<<(std::ostream& out, const GetReplicationMetricsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetReplicationMetricsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->scheduledExecutionId); + this->__isset.scheduledExecutionId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->policy); + this->__isset.policy = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->dumpExecutionId); + this->__isset.dumpExecutionId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t GetReplicationMetricsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetReplicationMetricsRequest"); + + if (this->__isset.scheduledExecutionId) { + xfer += oprot->writeFieldBegin("scheduledExecutionId", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->scheduledExecutionId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.policy) { + xfer += oprot->writeFieldBegin("policy", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->policy); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.dumpExecutionId) { + xfer += oprot->writeFieldBegin("dumpExecutionId", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->dumpExecutionId); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetReplicationMetricsRequest &a, GetReplicationMetricsRequest &b) noexcept { + using ::std::swap; + swap(a.scheduledExecutionId, b.scheduledExecutionId); + swap(a.policy, b.policy); + swap(a.dumpExecutionId, b.dumpExecutionId); + swap(a.__isset, b.__isset); +} + +bool GetReplicationMetricsRequest::operator==(const GetReplicationMetricsRequest & rhs) const +{ + if (__isset.scheduledExecutionId != rhs.__isset.scheduledExecutionId) + return false; + else if (__isset.scheduledExecutionId && !(scheduledExecutionId == rhs.scheduledExecutionId)) + return false; + if (__isset.policy != rhs.__isset.policy) + return false; + else if (__isset.policy && !(policy == rhs.policy)) + return false; + if (__isset.dumpExecutionId != rhs.__isset.dumpExecutionId) + return false; + else if (__isset.dumpExecutionId && !(dumpExecutionId == rhs.dumpExecutionId)) + return false; + return true; +} + +GetReplicationMetricsRequest::GetReplicationMetricsRequest(const GetReplicationMetricsRequest& other1824) { + scheduledExecutionId = other1824.scheduledExecutionId; + policy = other1824.policy; + dumpExecutionId = other1824.dumpExecutionId; + __isset = other1824.__isset; +} +GetReplicationMetricsRequest& GetReplicationMetricsRequest::operator=(const GetReplicationMetricsRequest& other1825) { + scheduledExecutionId = other1825.scheduledExecutionId; + policy = other1825.policy; + dumpExecutionId = other1825.dumpExecutionId; + __isset = other1825.__isset; + return *this; +} +void GetReplicationMetricsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetReplicationMetricsRequest("; + out << "scheduledExecutionId="; (__isset.scheduledExecutionId ? (out << to_string(scheduledExecutionId)) : (out << "")); + out << ", " << "policy="; (__isset.policy ? (out << to_string(policy)) : (out << "")); + out << ", " << "dumpExecutionId="; (__isset.dumpExecutionId ? (out << to_string(dumpExecutionId)) : (out << "")); + out << ")"; +} + + +GetOpenTxnsRequest::~GetOpenTxnsRequest() noexcept { +} + +GetOpenTxnsRequest::GetOpenTxnsRequest() noexcept { +} + +void GetOpenTxnsRequest::__set_excludeTxnTypes(const std::vector & val) { + this->excludeTxnTypes = val; +__isset.excludeTxnTypes = true; +} +std::ostream& operator<<(std::ostream& out, const GetOpenTxnsRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetOpenTxnsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->excludeTxnTypes.clear(); + uint32_t _size1826; + ::apache::thrift::protocol::TType _etype1829; + xfer += iprot->readListBegin(_etype1829, _size1826); + this->excludeTxnTypes.resize(_size1826); + uint32_t _i1830; + for (_i1830 = 0; _i1830 < _size1826; ++_i1830) + { + int32_t ecast1831; + xfer += iprot->readI32(ecast1831); + this->excludeTxnTypes[_i1830] = static_cast(ecast1831); + } + xfer += iprot->readListEnd(); + } + this->__isset.excludeTxnTypes = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t GetOpenTxnsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetOpenTxnsRequest"); + + if (this->__isset.excludeTxnTypes) { + xfer += oprot->writeFieldBegin("excludeTxnTypes", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I32, static_cast(this->excludeTxnTypes.size())); + std::vector ::const_iterator _iter1832; + for (_iter1832 = this->excludeTxnTypes.begin(); _iter1832 != this->excludeTxnTypes.end(); ++_iter1832) + { + xfer += oprot->writeI32(static_cast((*_iter1832))); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetOpenTxnsRequest &a, GetOpenTxnsRequest &b) noexcept { + using ::std::swap; + swap(a.excludeTxnTypes, b.excludeTxnTypes); + swap(a.__isset, b.__isset); +} + +bool GetOpenTxnsRequest::operator==(const GetOpenTxnsRequest & rhs) const +{ + if (__isset.excludeTxnTypes != rhs.__isset.excludeTxnTypes) + return false; + else if (__isset.excludeTxnTypes && !(excludeTxnTypes == rhs.excludeTxnTypes)) + return false; + return true; +} + +GetOpenTxnsRequest::GetOpenTxnsRequest(const GetOpenTxnsRequest& other1833) { + excludeTxnTypes = other1833.excludeTxnTypes; + __isset = other1833.__isset; +} +GetOpenTxnsRequest& GetOpenTxnsRequest::operator=(const GetOpenTxnsRequest& other1834) { + excludeTxnTypes = other1834.excludeTxnTypes; + __isset = other1834.__isset; + return *this; +} +void GetOpenTxnsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetOpenTxnsRequest("; + out << "excludeTxnTypes="; (__isset.excludeTxnTypes ? (out << to_string(excludeTxnTypes)) : (out << "")); + out << ")"; +} + + +StoredProcedureRequest::~StoredProcedureRequest() noexcept { +} + +StoredProcedureRequest::StoredProcedureRequest() noexcept + : catName(), + dbName(), + procName() { +} + +void StoredProcedureRequest::__set_catName(const std::string& val) { + this->catName = val; +} + +void StoredProcedureRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void StoredProcedureRequest::__set_procName(const std::string& val) { + this->procName = val; +} +std::ostream& operator<<(std::ostream& out, const StoredProcedureRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t StoredProcedureRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_catName = false; + bool isset_dbName = false; + bool isset_procName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + isset_catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->procName); + isset_procName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_catName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_procName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t StoredProcedureRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("StoredProcedureRequest"); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("procName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->procName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(StoredProcedureRequest &a, StoredProcedureRequest &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.dbName, b.dbName); + swap(a.procName, b.procName); +} + +bool StoredProcedureRequest::operator==(const StoredProcedureRequest & rhs) const +{ + if (!(catName == rhs.catName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(procName == rhs.procName)) + return false; + return true; +} + +StoredProcedureRequest::StoredProcedureRequest(const StoredProcedureRequest& other1835) { + catName = other1835.catName; + dbName = other1835.dbName; + procName = other1835.procName; +} +StoredProcedureRequest& StoredProcedureRequest::operator=(const StoredProcedureRequest& other1836) { + catName = other1836.catName; + dbName = other1836.dbName; + procName = other1836.procName; + return *this; +} +void StoredProcedureRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "StoredProcedureRequest("; + out << "catName=" << to_string(catName); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "procName=" << to_string(procName); + out << ")"; +} + + +ListStoredProcedureRequest::~ListStoredProcedureRequest() noexcept { +} + +ListStoredProcedureRequest::ListStoredProcedureRequest() noexcept + : catName(), + dbName() { +} + +void ListStoredProcedureRequest::__set_catName(const std::string& val) { + this->catName = val; +} + +void ListStoredProcedureRequest::__set_dbName(const std::string& val) { + this->dbName = val; +__isset.dbName = true; +} +std::ostream& operator<<(std::ostream& out, const ListStoredProcedureRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ListStoredProcedureRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_catName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + isset_catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_catName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ListStoredProcedureRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ListStoredProcedureRequest"); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.dbName) { + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ListStoredProcedureRequest &a, ListStoredProcedureRequest &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.dbName, b.dbName); + swap(a.__isset, b.__isset); +} + +bool ListStoredProcedureRequest::operator==(const ListStoredProcedureRequest & rhs) const +{ + if (!(catName == rhs.catName)) + return false; + if (__isset.dbName != rhs.__isset.dbName) + return false; + else if (__isset.dbName && !(dbName == rhs.dbName)) + return false; + return true; +} + +ListStoredProcedureRequest::ListStoredProcedureRequest(const ListStoredProcedureRequest& other1837) { + catName = other1837.catName; + dbName = other1837.dbName; + __isset = other1837.__isset; +} +ListStoredProcedureRequest& ListStoredProcedureRequest::operator=(const ListStoredProcedureRequest& other1838) { + catName = other1838.catName; + dbName = other1838.dbName; + __isset = other1838.__isset; + return *this; +} +void ListStoredProcedureRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ListStoredProcedureRequest("; + out << "catName=" << to_string(catName); + out << ", " << "dbName="; (__isset.dbName ? (out << to_string(dbName)) : (out << "")); + out << ")"; +} + + +StoredProcedure::~StoredProcedure() noexcept { +} + +StoredProcedure::StoredProcedure() noexcept + : name(), + dbName(), + catName(), + ownerName(), + source() { +} + +void StoredProcedure::__set_name(const std::string& val) { + this->name = val; +} + +void StoredProcedure::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void StoredProcedure::__set_catName(const std::string& val) { + this->catName = val; +} + +void StoredProcedure::__set_ownerName(const std::string& val) { + this->ownerName = val; +} + +void StoredProcedure::__set_source(const std::string& val) { + this->source = val; +} +std::ostream& operator<<(std::ostream& out, const StoredProcedure& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t StoredProcedure::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ownerName); + this->__isset.ownerName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->source); + this->__isset.source = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t StoredProcedure::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("StoredProcedure"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("ownerName", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->ownerName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("source", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->source); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(StoredProcedure &a, StoredProcedure &b) noexcept { + using ::std::swap; + swap(a.name, b.name); + swap(a.dbName, b.dbName); + swap(a.catName, b.catName); + swap(a.ownerName, b.ownerName); + swap(a.source, b.source); + swap(a.__isset, b.__isset); +} + +bool StoredProcedure::operator==(const StoredProcedure & rhs) const +{ + if (!(name == rhs.name)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(catName == rhs.catName)) + return false; + if (!(ownerName == rhs.ownerName)) + return false; + if (!(source == rhs.source)) + return false; + return true; +} + +StoredProcedure::StoredProcedure(const StoredProcedure& other1839) { + name = other1839.name; + dbName = other1839.dbName; + catName = other1839.catName; + ownerName = other1839.ownerName; + source = other1839.source; + __isset = other1839.__isset; +} +StoredProcedure& StoredProcedure::operator=(const StoredProcedure& other1840) { + name = other1840.name; + dbName = other1840.dbName; + catName = other1840.catName; + ownerName = other1840.ownerName; + source = other1840.source; + __isset = other1840.__isset; + return *this; +} +void StoredProcedure::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "StoredProcedure("; + out << "name=" << to_string(name); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "catName=" << to_string(catName); + out << ", " << "ownerName=" << to_string(ownerName); + out << ", " << "source=" << to_string(source); + out << ")"; +} + + +AddPackageRequest::~AddPackageRequest() noexcept { +} + +AddPackageRequest::AddPackageRequest() noexcept + : catName(), + dbName(), + packageName(), + ownerName(), + header(), + body() { +} + +void AddPackageRequest::__set_catName(const std::string& val) { + this->catName = val; +} + +void AddPackageRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void AddPackageRequest::__set_packageName(const std::string& val) { + this->packageName = val; +} + +void AddPackageRequest::__set_ownerName(const std::string& val) { + this->ownerName = val; +} + +void AddPackageRequest::__set_header(const std::string& val) { + this->header = val; +} + +void AddPackageRequest::__set_body(const std::string& val) { + this->body = val; +} +std::ostream& operator<<(std::ostream& out, const AddPackageRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AddPackageRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->packageName); + this->__isset.packageName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ownerName); + this->__isset.ownerName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->header); + this->__isset.header = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->body); + this->__isset.body = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t AddPackageRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AddPackageRequest"); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("packageName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->packageName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("ownerName", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->ownerName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("header", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->header); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("body", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->body); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AddPackageRequest &a, AddPackageRequest &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.dbName, b.dbName); + swap(a.packageName, b.packageName); + swap(a.ownerName, b.ownerName); + swap(a.header, b.header); + swap(a.body, b.body); + swap(a.__isset, b.__isset); +} + +bool AddPackageRequest::operator==(const AddPackageRequest & rhs) const +{ + if (!(catName == rhs.catName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(packageName == rhs.packageName)) + return false; + if (!(ownerName == rhs.ownerName)) + return false; + if (!(header == rhs.header)) + return false; + if (!(body == rhs.body)) + return false; + return true; +} + +AddPackageRequest::AddPackageRequest(const AddPackageRequest& other1841) { + catName = other1841.catName; + dbName = other1841.dbName; + packageName = other1841.packageName; + ownerName = other1841.ownerName; + header = other1841.header; + body = other1841.body; + __isset = other1841.__isset; +} +AddPackageRequest& AddPackageRequest::operator=(const AddPackageRequest& other1842) { + catName = other1842.catName; + dbName = other1842.dbName; + packageName = other1842.packageName; + ownerName = other1842.ownerName; + header = other1842.header; + body = other1842.body; + __isset = other1842.__isset; + return *this; +} +void AddPackageRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AddPackageRequest("; + out << "catName=" << to_string(catName); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "packageName=" << to_string(packageName); + out << ", " << "ownerName=" << to_string(ownerName); + out << ", " << "header=" << to_string(header); + out << ", " << "body=" << to_string(body); + out << ")"; +} + + +GetPackageRequest::~GetPackageRequest() noexcept { +} + +GetPackageRequest::GetPackageRequest() noexcept + : catName(), + dbName(), + packageName() { +} + +void GetPackageRequest::__set_catName(const std::string& val) { + this->catName = val; +} + +void GetPackageRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void GetPackageRequest::__set_packageName(const std::string& val) { + this->packageName = val; +} +std::ostream& operator<<(std::ostream& out, const GetPackageRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetPackageRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_catName = false; + bool isset_dbName = false; + bool isset_packageName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + isset_catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->packageName); + isset_packageName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_catName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_packageName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetPackageRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetPackageRequest"); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("packageName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->packageName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetPackageRequest &a, GetPackageRequest &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.dbName, b.dbName); + swap(a.packageName, b.packageName); +} + +bool GetPackageRequest::operator==(const GetPackageRequest & rhs) const +{ + if (!(catName == rhs.catName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(packageName == rhs.packageName)) + return false; + return true; +} + +GetPackageRequest::GetPackageRequest(const GetPackageRequest& other1843) { + catName = other1843.catName; + dbName = other1843.dbName; + packageName = other1843.packageName; +} +GetPackageRequest& GetPackageRequest::operator=(const GetPackageRequest& other1844) { + catName = other1844.catName; + dbName = other1844.dbName; + packageName = other1844.packageName; + return *this; +} +void GetPackageRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetPackageRequest("; + out << "catName=" << to_string(catName); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "packageName=" << to_string(packageName); + out << ")"; +} + + +DropPackageRequest::~DropPackageRequest() noexcept { +} + +DropPackageRequest::DropPackageRequest() noexcept + : catName(), + dbName(), + packageName() { +} + +void DropPackageRequest::__set_catName(const std::string& val) { + this->catName = val; +} + +void DropPackageRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void DropPackageRequest::__set_packageName(const std::string& val) { + this->packageName = val; +} +std::ostream& operator<<(std::ostream& out, const DropPackageRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t DropPackageRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_catName = false; + bool isset_dbName = false; + bool isset_packageName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + isset_catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->packageName); + isset_packageName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_catName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_packageName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t DropPackageRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("DropPackageRequest"); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("packageName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->packageName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(DropPackageRequest &a, DropPackageRequest &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.dbName, b.dbName); + swap(a.packageName, b.packageName); +} + +bool DropPackageRequest::operator==(const DropPackageRequest & rhs) const +{ + if (!(catName == rhs.catName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(packageName == rhs.packageName)) + return false; + return true; +} + +DropPackageRequest::DropPackageRequest(const DropPackageRequest& other1845) { + catName = other1845.catName; + dbName = other1845.dbName; + packageName = other1845.packageName; +} +DropPackageRequest& DropPackageRequest::operator=(const DropPackageRequest& other1846) { + catName = other1846.catName; + dbName = other1846.dbName; + packageName = other1846.packageName; + return *this; +} +void DropPackageRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "DropPackageRequest("; + out << "catName=" << to_string(catName); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "packageName=" << to_string(packageName); + out << ")"; +} + + +ListPackageRequest::~ListPackageRequest() noexcept { +} + +ListPackageRequest::ListPackageRequest() noexcept + : catName(), + dbName() { +} + +void ListPackageRequest::__set_catName(const std::string& val) { + this->catName = val; +} + +void ListPackageRequest::__set_dbName(const std::string& val) { + this->dbName = val; +__isset.dbName = true; +} +std::ostream& operator<<(std::ostream& out, const ListPackageRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ListPackageRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_catName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + isset_catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_catName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ListPackageRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ListPackageRequest"); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.dbName) { + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ListPackageRequest &a, ListPackageRequest &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.dbName, b.dbName); + swap(a.__isset, b.__isset); +} + +bool ListPackageRequest::operator==(const ListPackageRequest & rhs) const +{ + if (!(catName == rhs.catName)) + return false; + if (__isset.dbName != rhs.__isset.dbName) + return false; + else if (__isset.dbName && !(dbName == rhs.dbName)) + return false; + return true; +} + +ListPackageRequest::ListPackageRequest(const ListPackageRequest& other1847) { + catName = other1847.catName; + dbName = other1847.dbName; + __isset = other1847.__isset; +} +ListPackageRequest& ListPackageRequest::operator=(const ListPackageRequest& other1848) { + catName = other1848.catName; + dbName = other1848.dbName; + __isset = other1848.__isset; + return *this; +} +void ListPackageRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ListPackageRequest("; + out << "catName=" << to_string(catName); + out << ", " << "dbName="; (__isset.dbName ? (out << to_string(dbName)) : (out << "")); + out << ")"; +} + + +Package::~Package() noexcept { +} + +Package::Package() noexcept + : catName(), + dbName(), + packageName(), + ownerName(), + header(), + body() { +} + +void Package::__set_catName(const std::string& val) { + this->catName = val; +} + +void Package::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void Package::__set_packageName(const std::string& val) { + this->packageName = val; +} + +void Package::__set_ownerName(const std::string& val) { + this->ownerName = val; +} + +void Package::__set_header(const std::string& val) { + this->header = val; +} + +void Package::__set_body(const std::string& val) { + this->body = val; +} +std::ostream& operator<<(std::ostream& out, const Package& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Package::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->packageName); + this->__isset.packageName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ownerName); + this->__isset.ownerName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->header); + this->__isset.header = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->body); + this->__isset.body = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Package::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Package"); + + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("packageName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->packageName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("ownerName", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->ownerName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("header", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->header); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("body", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->body); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Package &a, Package &b) noexcept { + using ::std::swap; + swap(a.catName, b.catName); + swap(a.dbName, b.dbName); + swap(a.packageName, b.packageName); + swap(a.ownerName, b.ownerName); + swap(a.header, b.header); + swap(a.body, b.body); + swap(a.__isset, b.__isset); +} + +bool Package::operator==(const Package & rhs) const +{ + if (!(catName == rhs.catName)) + return false; + if (!(dbName == rhs.dbName)) + return false; + if (!(packageName == rhs.packageName)) + return false; + if (!(ownerName == rhs.ownerName)) + return false; + if (!(header == rhs.header)) + return false; + if (!(body == rhs.body)) + return false; + return true; +} + +Package::Package(const Package& other1849) { + catName = other1849.catName; + dbName = other1849.dbName; + packageName = other1849.packageName; + ownerName = other1849.ownerName; + header = other1849.header; + body = other1849.body; + __isset = other1849.__isset; +} +Package& Package::operator=(const Package& other1850) { + catName = other1850.catName; + dbName = other1850.dbName; + packageName = other1850.packageName; + ownerName = other1850.ownerName; + header = other1850.header; + body = other1850.body; + __isset = other1850.__isset; + return *this; +} +void Package::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Package("; + out << "catName=" << to_string(catName); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "packageName=" << to_string(packageName); + out << ", " << "ownerName=" << to_string(ownerName); + out << ", " << "header=" << to_string(header); + out << ", " << "body=" << to_string(body); + out << ")"; +} + + +GetAllWriteEventInfoRequest::~GetAllWriteEventInfoRequest() noexcept { +} + +GetAllWriteEventInfoRequest::GetAllWriteEventInfoRequest() noexcept + : txnId(0), + dbName(), + tableName() { +} + +void GetAllWriteEventInfoRequest::__set_txnId(const int64_t val) { + this->txnId = val; +} + +void GetAllWriteEventInfoRequest::__set_dbName(const std::string& val) { + this->dbName = val; +__isset.dbName = true; +} + +void GetAllWriteEventInfoRequest::__set_tableName(const std::string& val) { + this->tableName = val; +__isset.tableName = true; +} +std::ostream& operator<<(std::ostream& out, const GetAllWriteEventInfoRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t GetAllWriteEventInfoRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_txnId = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->txnId); + isset_txnId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + this->__isset.tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_txnId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetAllWriteEventInfoRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetAllWriteEventInfoRequest"); + + xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->txnId); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.dbName) { + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.tableName) { + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetAllWriteEventInfoRequest &a, GetAllWriteEventInfoRequest &b) noexcept { + using ::std::swap; + swap(a.txnId, b.txnId); + swap(a.dbName, b.dbName); + swap(a.tableName, b.tableName); + swap(a.__isset, b.__isset); +} + +bool GetAllWriteEventInfoRequest::operator==(const GetAllWriteEventInfoRequest & rhs) const +{ + if (!(txnId == rhs.txnId)) + return false; + if (__isset.dbName != rhs.__isset.dbName) + return false; + else if (__isset.dbName && !(dbName == rhs.dbName)) + return false; + if (__isset.tableName != rhs.__isset.tableName) + return false; + else if (__isset.tableName && !(tableName == rhs.tableName)) + return false; + return true; +} + +GetAllWriteEventInfoRequest::GetAllWriteEventInfoRequest(const GetAllWriteEventInfoRequest& other1851) { + txnId = other1851.txnId; + dbName = other1851.dbName; + tableName = other1851.tableName; + __isset = other1851.__isset; +} +GetAllWriteEventInfoRequest& GetAllWriteEventInfoRequest::operator=(const GetAllWriteEventInfoRequest& other1852) { + txnId = other1852.txnId; + dbName = other1852.dbName; + tableName = other1852.tableName; + __isset = other1852.__isset; + return *this; +} +void GetAllWriteEventInfoRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetAllWriteEventInfoRequest("; + out << "txnId=" << to_string(txnId); + out << ", " << "dbName="; (__isset.dbName ? (out << to_string(dbName)) : (out << "")); + out << ", " << "tableName="; (__isset.tableName ? (out << to_string(tableName)) : (out << "")); + out << ")"; +} + + +MetaException::~MetaException() noexcept { +} + +MetaException::MetaException() noexcept + : message() { +} + +void MetaException::__set_message(const std::string& val) { + this->message = val; +} +std::ostream& operator<<(std::ostream& out, const MetaException& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t MetaException::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t MetaException::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("MetaException"); + + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(MetaException &a, MetaException &b) noexcept { + using ::std::swap; + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +bool MetaException::operator==(const MetaException & rhs) const +{ + if (!(message == rhs.message)) + return false; + return true; +} + +MetaException::MetaException(const MetaException& other1853) : TException() { + message = other1853.message; + __isset = other1853.__isset; +} +MetaException& MetaException::operator=(const MetaException& other1854) { + message = other1854.message; + __isset = other1854.__isset; + return *this; +} +void MetaException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "MetaException("; + out << "message=" << to_string(message); + out << ")"; +} + +const char* MetaException::what() const noexcept { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: MetaException"; + } +} + + +UnknownTableException::~UnknownTableException() noexcept { +} + +UnknownTableException::UnknownTableException() noexcept + : message() { +} + +void UnknownTableException::__set_message(const std::string& val) { + this->message = val; +} +std::ostream& operator<<(std::ostream& out, const UnknownTableException& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t UnknownTableException::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t UnknownTableException::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("UnknownTableException"); + + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(UnknownTableException &a, UnknownTableException &b) noexcept { + using ::std::swap; + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +bool UnknownTableException::operator==(const UnknownTableException & rhs) const +{ + if (!(message == rhs.message)) + return false; + return true; +} + +UnknownTableException::UnknownTableException(const UnknownTableException& other1855) : TException() { + message = other1855.message; + __isset = other1855.__isset; +} +UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other1856) { + message = other1856.message; + __isset = other1856.__isset; + return *this; +} +void UnknownTableException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "UnknownTableException("; + out << "message=" << to_string(message); + out << ")"; +} + +const char* UnknownTableException::what() const noexcept { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: UnknownTableException"; + } +} + + +UnknownDBException::~UnknownDBException() noexcept { +} + +UnknownDBException::UnknownDBException() noexcept + : message() { +} + +void UnknownDBException::__set_message(const std::string& val) { + this->message = val; +} +std::ostream& operator<<(std::ostream& out, const UnknownDBException& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t UnknownDBException::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t UnknownDBException::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("UnknownDBException"); + + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(UnknownDBException &a, UnknownDBException &b) noexcept { + using ::std::swap; + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +bool UnknownDBException::operator==(const UnknownDBException & rhs) const +{ + if (!(message == rhs.message)) + return false; + return true; +} + +UnknownDBException::UnknownDBException(const UnknownDBException& other1857) : TException() { + message = other1857.message; + __isset = other1857.__isset; +} +UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other1858) { + message = other1858.message; + __isset = other1858.__isset; + return *this; +} +void UnknownDBException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "UnknownDBException("; + out << "message=" << to_string(message); + out << ")"; +} + +const char* UnknownDBException::what() const noexcept { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: UnknownDBException"; + } +} + + +AlreadyExistsException::~AlreadyExistsException() noexcept { +} + +AlreadyExistsException::AlreadyExistsException() noexcept + : message() { +} + +void AlreadyExistsException::__set_message(const std::string& val) { + this->message = val; +} +std::ostream& operator<<(std::ostream& out, const AlreadyExistsException& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t AlreadyExistsException::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t AlreadyExistsException::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AlreadyExistsException"); + + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AlreadyExistsException &a, AlreadyExistsException &b) noexcept { + using ::std::swap; + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +bool AlreadyExistsException::operator==(const AlreadyExistsException & rhs) const +{ + if (!(message == rhs.message)) + return false; + return true; +} + +AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other1859) : TException() { + message = other1859.message; + __isset = other1859.__isset; +} +AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other1860) { + message = other1860.message; + __isset = other1860.__isset; + return *this; +} +void AlreadyExistsException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AlreadyExistsException("; + out << "message=" << to_string(message); + out << ")"; +} + +const char* AlreadyExistsException::what() const noexcept { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: AlreadyExistsException"; + } +} + + +InvalidPartitionException::~InvalidPartitionException() noexcept { +} + +InvalidPartitionException::InvalidPartitionException() noexcept + : message() { +} + +void InvalidPartitionException::__set_message(const std::string& val) { + this->message = val; +} +std::ostream& operator<<(std::ostream& out, const InvalidPartitionException& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t InvalidPartitionException::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t InvalidPartitionException::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("InvalidPartitionException"); + + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(InvalidPartitionException &a, InvalidPartitionException &b) noexcept { + using ::std::swap; + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +bool InvalidPartitionException::operator==(const InvalidPartitionException & rhs) const +{ + if (!(message == rhs.message)) + return false; + return true; +} + +InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other1861) : TException() { + message = other1861.message; + __isset = other1861.__isset; +} +InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other1862) { + message = other1862.message; + __isset = other1862.__isset; + return *this; +} +void InvalidPartitionException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "InvalidPartitionException("; + out << "message=" << to_string(message); + out << ")"; +} + +const char* InvalidPartitionException::what() const noexcept { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: InvalidPartitionException"; + } +} + + +UnknownPartitionException::~UnknownPartitionException() noexcept { +} + +UnknownPartitionException::UnknownPartitionException() noexcept + : message() { +} + +void UnknownPartitionException::__set_message(const std::string& val) { + this->message = val; +} +std::ostream& operator<<(std::ostream& out, const UnknownPartitionException& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t UnknownPartitionException::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t UnknownPartitionException::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("UnknownPartitionException"); + + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(UnknownPartitionException &a, UnknownPartitionException &b) noexcept { + using ::std::swap; + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +bool UnknownPartitionException::operator==(const UnknownPartitionException & rhs) const +{ + if (!(message == rhs.message)) + return false; + return true; +} + +UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other1863) : TException() { + message = other1863.message; + __isset = other1863.__isset; +} +UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other1864) { + message = other1864.message; + __isset = other1864.__isset; + return *this; +} +void UnknownPartitionException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "UnknownPartitionException("; + out << "message=" << to_string(message); + out << ")"; +} + +const char* UnknownPartitionException::what() const noexcept { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: UnknownPartitionException"; + } +} + + +InvalidObjectException::~InvalidObjectException() noexcept { +} + +InvalidObjectException::InvalidObjectException() noexcept + : message() { +} + +void InvalidObjectException::__set_message(const std::string& val) { + this->message = val; +} +std::ostream& operator<<(std::ostream& out, const InvalidObjectException& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t InvalidObjectException::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t InvalidObjectException::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("InvalidObjectException"); + + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(InvalidObjectException &a, InvalidObjectException &b) noexcept { + using ::std::swap; + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +bool InvalidObjectException::operator==(const InvalidObjectException & rhs) const +{ + if (!(message == rhs.message)) + return false; + return true; +} + +InvalidObjectException::InvalidObjectException(const InvalidObjectException& other1865) : TException() { + message = other1865.message; + __isset = other1865.__isset; +} +InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other1866) { + message = other1866.message; + __isset = other1866.__isset; + return *this; +} +void InvalidObjectException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "InvalidObjectException("; + out << "message=" << to_string(message); + out << ")"; +} + +const char* InvalidObjectException::what() const noexcept { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: InvalidObjectException"; + } +} + + +NoSuchObjectException::~NoSuchObjectException() noexcept { +} + +NoSuchObjectException::NoSuchObjectException() noexcept + : message() { +} + +void NoSuchObjectException::__set_message(const std::string& val) { + this->message = val; +} +std::ostream& operator<<(std::ostream& out, const NoSuchObjectException& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t NoSuchObjectException::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t NoSuchObjectException::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("NoSuchObjectException"); + + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(NoSuchObjectException &a, NoSuchObjectException &b) noexcept { + using ::std::swap; + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +bool NoSuchObjectException::operator==(const NoSuchObjectException & rhs) const +{ + if (!(message == rhs.message)) + return false; + return true; +} + +NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other1867) : TException() { + message = other1867.message; + __isset = other1867.__isset; +} +NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other1868) { + message = other1868.message; + __isset = other1868.__isset; + return *this; +} +void NoSuchObjectException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "NoSuchObjectException("; + out << "message=" << to_string(message); + out << ")"; +} + +const char* NoSuchObjectException::what() const noexcept { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: NoSuchObjectException"; + } +} + + +InvalidOperationException::~InvalidOperationException() noexcept { +} + +InvalidOperationException::InvalidOperationException() noexcept + : message() { +} + +void InvalidOperationException::__set_message(const std::string& val) { + this->message = val; +} +std::ostream& operator<<(std::ostream& out, const InvalidOperationException& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t InvalidOperationException::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t InvalidOperationException::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("InvalidOperationException"); + + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(InvalidOperationException &a, InvalidOperationException &b) noexcept { + using ::std::swap; + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +bool InvalidOperationException::operator==(const InvalidOperationException & rhs) const +{ + if (!(message == rhs.message)) + return false; + return true; +} + +InvalidOperationException::InvalidOperationException(const InvalidOperationException& other1869) : TException() { + message = other1869.message; + __isset = other1869.__isset; +} +InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other1870) { + message = other1870.message; + __isset = other1870.__isset; + return *this; +} +void InvalidOperationException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "InvalidOperationException("; + out << "message=" << to_string(message); + out << ")"; +} + +const char* InvalidOperationException::what() const noexcept { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: InvalidOperationException"; + } +} + + +ConfigValSecurityException::~ConfigValSecurityException() noexcept { +} + +ConfigValSecurityException::ConfigValSecurityException() noexcept + : message() { +} + +void ConfigValSecurityException::__set_message(const std::string& val) { + this->message = val; +} +std::ostream& operator<<(std::ostream& out, const ConfigValSecurityException& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ConfigValSecurityException::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ConfigValSecurityException::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ConfigValSecurityException"); + + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) noexcept { + using ::std::swap; + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +bool ConfigValSecurityException::operator==(const ConfigValSecurityException & rhs) const +{ + if (!(message == rhs.message)) + return false; + return true; +} + +ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other1871) : TException() { + message = other1871.message; + __isset = other1871.__isset; +} +ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other1872) { + message = other1872.message; + __isset = other1872.__isset; + return *this; +} +void ConfigValSecurityException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ConfigValSecurityException("; + out << "message=" << to_string(message); + out << ")"; +} + +const char* ConfigValSecurityException::what() const noexcept { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: ConfigValSecurityException"; + } +} + + +InvalidInputException::~InvalidInputException() noexcept { +} + +InvalidInputException::InvalidInputException() noexcept + : message() { +} + +void InvalidInputException::__set_message(const std::string& val) { + this->message = val; +} +std::ostream& operator<<(std::ostream& out, const InvalidInputException& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t InvalidInputException::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t InvalidInputException::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("InvalidInputException"); + + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(InvalidInputException &a, InvalidInputException &b) noexcept { + using ::std::swap; + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +bool InvalidInputException::operator==(const InvalidInputException & rhs) const +{ + if (!(message == rhs.message)) + return false; + return true; +} + +InvalidInputException::InvalidInputException(const InvalidInputException& other1873) : TException() { + message = other1873.message; + __isset = other1873.__isset; +} +InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other1874) { + message = other1874.message; + __isset = other1874.__isset; + return *this; +} +void InvalidInputException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "InvalidInputException("; + out << "message=" << to_string(message); + out << ")"; +} + +const char* InvalidInputException::what() const noexcept { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: InvalidInputException"; + } +} + + +NoSuchTxnException::~NoSuchTxnException() noexcept { +} + +NoSuchTxnException::NoSuchTxnException() noexcept + : message() { +} + +void NoSuchTxnException::__set_message(const std::string& val) { + this->message = val; +} +std::ostream& operator<<(std::ostream& out, const NoSuchTxnException& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t NoSuchTxnException::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t NoSuchTxnException::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("NoSuchTxnException"); + + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(NoSuchTxnException &a, NoSuchTxnException &b) noexcept { + using ::std::swap; + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +bool NoSuchTxnException::operator==(const NoSuchTxnException & rhs) const +{ + if (!(message == rhs.message)) + return false; + return true; +} + +NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other1875) : TException() { + message = other1875.message; + __isset = other1875.__isset; +} +NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other1876) { + message = other1876.message; + __isset = other1876.__isset; + return *this; +} +void NoSuchTxnException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "NoSuchTxnException("; + out << "message=" << to_string(message); + out << ")"; +} + +const char* NoSuchTxnException::what() const noexcept { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: NoSuchTxnException"; + } +} + + +TxnAbortedException::~TxnAbortedException() noexcept { +} + +TxnAbortedException::TxnAbortedException() noexcept + : message() { +} + +void TxnAbortedException::__set_message(const std::string& val) { + this->message = val; +} +std::ostream& operator<<(std::ostream& out, const TxnAbortedException& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t TxnAbortedException::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t TxnAbortedException::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("TxnAbortedException"); + + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(TxnAbortedException &a, TxnAbortedException &b) noexcept { + using ::std::swap; + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +bool TxnAbortedException::operator==(const TxnAbortedException & rhs) const +{ + if (!(message == rhs.message)) + return false; + return true; +} + +TxnAbortedException::TxnAbortedException(const TxnAbortedException& other1877) : TException() { + message = other1877.message; + __isset = other1877.__isset; +} +TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other1878) { + message = other1878.message; + __isset = other1878.__isset; + return *this; +} +void TxnAbortedException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "TxnAbortedException("; + out << "message=" << to_string(message); + out << ")"; +} + +const char* TxnAbortedException::what() const noexcept { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: TxnAbortedException"; + } +} + + +TxnOpenException::~TxnOpenException() noexcept { +} + +TxnOpenException::TxnOpenException() noexcept + : message() { +} + +void TxnOpenException::__set_message(const std::string& val) { + this->message = val; +} +std::ostream& operator<<(std::ostream& out, const TxnOpenException& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t TxnOpenException::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t TxnOpenException::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("TxnOpenException"); + + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(TxnOpenException &a, TxnOpenException &b) noexcept { + using ::std::swap; + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +bool TxnOpenException::operator==(const TxnOpenException & rhs) const +{ + if (!(message == rhs.message)) + return false; + return true; +} + +TxnOpenException::TxnOpenException(const TxnOpenException& other1879) : TException() { + message = other1879.message; + __isset = other1879.__isset; +} +TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other1880) { + message = other1880.message; + __isset = other1880.__isset; + return *this; +} +void TxnOpenException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "TxnOpenException("; + out << "message=" << to_string(message); + out << ")"; +} + +const char* TxnOpenException::what() const noexcept { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: TxnOpenException"; + } +} + + +NoSuchLockException::~NoSuchLockException() noexcept { +} + +NoSuchLockException::NoSuchLockException() noexcept + : message() { +} + +void NoSuchLockException::__set_message(const std::string& val) { + this->message = val; +} +std::ostream& operator<<(std::ostream& out, const NoSuchLockException& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t NoSuchLockException::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t NoSuchLockException::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("NoSuchLockException"); + + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(NoSuchLockException &a, NoSuchLockException &b) noexcept { + using ::std::swap; + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +bool NoSuchLockException::operator==(const NoSuchLockException & rhs) const +{ + if (!(message == rhs.message)) + return false; + return true; +} + +NoSuchLockException::NoSuchLockException(const NoSuchLockException& other1881) : TException() { + message = other1881.message; + __isset = other1881.__isset; +} +NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other1882) { + message = other1882.message; + __isset = other1882.__isset; + return *this; +} +void NoSuchLockException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "NoSuchLockException("; + out << "message=" << to_string(message); + out << ")"; +} + +const char* NoSuchLockException::what() const noexcept { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: NoSuchLockException"; + } +} + + +CompactionAbortedException::~CompactionAbortedException() noexcept { +} + +CompactionAbortedException::CompactionAbortedException() noexcept + : message() { +} + +void CompactionAbortedException::__set_message(const std::string& val) { + this->message = val; +} +std::ostream& operator<<(std::ostream& out, const CompactionAbortedException& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t CompactionAbortedException::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t CompactionAbortedException::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CompactionAbortedException"); + + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CompactionAbortedException &a, CompactionAbortedException &b) noexcept { + using ::std::swap; + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +bool CompactionAbortedException::operator==(const CompactionAbortedException & rhs) const +{ + if (!(message == rhs.message)) + return false; + return true; +} + +CompactionAbortedException::CompactionAbortedException(const CompactionAbortedException& other1883) : TException() { + message = other1883.message; + __isset = other1883.__isset; +} +CompactionAbortedException& CompactionAbortedException::operator=(const CompactionAbortedException& other1884) { + message = other1884.message; + __isset = other1884.__isset; + return *this; +} +void CompactionAbortedException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CompactionAbortedException("; + out << "message=" << to_string(message); + out << ")"; +} + +const char* CompactionAbortedException::what() const noexcept { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: CompactionAbortedException"; + } +} + + +NoSuchCompactionException::~NoSuchCompactionException() noexcept { +} + +NoSuchCompactionException::NoSuchCompactionException() noexcept + : message() { +} + +void NoSuchCompactionException::__set_message(const std::string& val) { + this->message = val; +} +std::ostream& operator<<(std::ostream& out, const NoSuchCompactionException& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t NoSuchCompactionException::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t NoSuchCompactionException::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("NoSuchCompactionException"); + + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(NoSuchCompactionException &a, NoSuchCompactionException &b) noexcept { + using ::std::swap; + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +bool NoSuchCompactionException::operator==(const NoSuchCompactionException & rhs) const +{ + if (!(message == rhs.message)) + return false; + return true; +} + +NoSuchCompactionException::NoSuchCompactionException(const NoSuchCompactionException& other1885) : TException() { + message = other1885.message; + __isset = other1885.__isset; +} +NoSuchCompactionException& NoSuchCompactionException::operator=(const NoSuchCompactionException& other1886) { + message = other1886.message; + __isset = other1886.__isset; + return *this; +} +void NoSuchCompactionException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "NoSuchCompactionException("; + out << "message=" << to_string(message); + out << ")"; +} + +const char* NoSuchCompactionException::what() const noexcept { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: NoSuchCompactionException"; + } +} + +}}} // namespace diff --git a/src/iceberg/catalog/hive/gen-cpp/hive_metastore_types.h b/src/iceberg/catalog/hive/gen-cpp/hive_metastore_types.h new file mode 100644 index 000000000..07e790141 --- /dev/null +++ b/src/iceberg/catalog/hive/gen-cpp/hive_metastore_types.h @@ -0,0 +1,15912 @@ +/** + * Autogenerated by Thrift Compiler (0.23.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef hive_metastore_TYPES_H +#define hive_metastore_TYPES_H + +#include + +#include +#include +#include +#include +#include + +#include +#include +#include "fb303_types.h" + + +namespace Apache { namespace Hadoop { namespace Hive { + +struct HiveObjectType { + enum type { + GLOBAL = 1, + DATABASE = 2, + TABLE = 3, + PARTITION = 4, + COLUMN = 5, + DATACONNECTOR = 6 + }; +}; + +extern const std::map _HiveObjectType_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const HiveObjectType::type& val); + +std::string to_string(const HiveObjectType::type& val); + +struct PrincipalType { + enum type { + USER = 1, + ROLE = 2, + GROUP = 3 + }; +}; + +extern const std::map _PrincipalType_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const PrincipalType::type& val); + +std::string to_string(const PrincipalType::type& val); + +struct PartitionEventType { + enum type { + LOAD_DONE = 1 + }; +}; + +extern const std::map _PartitionEventType_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const PartitionEventType::type& val); + +std::string to_string(const PartitionEventType::type& val); + +struct TxnState { + enum type { + COMMITTED = 1, + ABORTED = 2, + OPEN = 3 + }; +}; + +extern const std::map _TxnState_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const TxnState::type& val); + +std::string to_string(const TxnState::type& val); + +struct LockLevel { + enum type { + DB = 1, + TABLE = 2, + PARTITION = 3 + }; +}; + +extern const std::map _LockLevel_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const LockLevel::type& val); + +std::string to_string(const LockLevel::type& val); + +struct LockState { + enum type { + ACQUIRED = 1, + WAITING = 2, + ABORT = 3, + NOT_ACQUIRED = 4 + }; +}; + +extern const std::map _LockState_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const LockState::type& val); + +std::string to_string(const LockState::type& val); + +struct LockType { + enum type { + SHARED_READ = 1, + SHARED_WRITE = 2, + EXCLUSIVE = 3, + EXCL_WRITE = 4 + }; +}; + +extern const std::map _LockType_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const LockType::type& val); + +std::string to_string(const LockType::type& val); + +struct CompactionType { + enum type { + MINOR = 1, + MAJOR = 2, + REBALANCE = 3, + ABORT_TXN_CLEANUP = 4 + }; +}; + +extern const std::map _CompactionType_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const CompactionType::type& val); + +std::string to_string(const CompactionType::type& val); + +struct GrantRevokeType { + enum type { + GRANT = 1, + REVOKE = 2 + }; +}; + +extern const std::map _GrantRevokeType_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const GrantRevokeType::type& val); + +std::string to_string(const GrantRevokeType::type& val); + +struct DataOperationType { + enum type { + SELECT = 1, + INSERT = 2, + UPDATE = 3, + DELETE = 4, + UNSET = 5, + NO_TXN = 6 + }; +}; + +extern const std::map _DataOperationType_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const DataOperationType::type& val); + +std::string to_string(const DataOperationType::type& val); + +struct EventRequestType { + enum type { + INSERT = 1, + UPDATE = 2, + DELETE = 3 + }; +}; + +extern const std::map _EventRequestType_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const EventRequestType::type& val); + +std::string to_string(const EventRequestType::type& val); + +struct SerdeType { + enum type { + HIVE = 1, + SCHEMA_REGISTRY = 2 + }; +}; + +extern const std::map _SerdeType_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const SerdeType::type& val); + +std::string to_string(const SerdeType::type& val); + +struct SchemaType { + enum type { + HIVE = 1, + AVRO = 2 + }; +}; + +extern const std::map _SchemaType_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const SchemaType::type& val); + +std::string to_string(const SchemaType::type& val); + +struct SchemaCompatibility { + enum type { + NONE = 1, + BACKWARD = 2, + FORWARD = 3, + BOTH = 4 + }; +}; + +extern const std::map _SchemaCompatibility_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const SchemaCompatibility::type& val); + +std::string to_string(const SchemaCompatibility::type& val); + +struct SchemaValidation { + enum type { + LATEST = 1, + ALL = 2 + }; +}; + +extern const std::map _SchemaValidation_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const SchemaValidation::type& val); + +std::string to_string(const SchemaValidation::type& val); + +struct SchemaVersionState { + enum type { + INITIATED = 1, + START_REVIEW = 2, + CHANGES_REQUIRED = 3, + REVIEWED = 4, + ENABLED = 5, + DISABLED = 6, + ARCHIVED = 7, + DELETED = 8 + }; +}; + +extern const std::map _SchemaVersionState_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const SchemaVersionState::type& val); + +std::string to_string(const SchemaVersionState::type& val); + +struct DatabaseType { + enum type { + NATIVE = 1, + REMOTE = 2 + }; +}; + +extern const std::map _DatabaseType_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const DatabaseType::type& val); + +std::string to_string(const DatabaseType::type& val); + +struct FunctionType { + enum type { + JAVA = 1 + }; +}; + +extern const std::map _FunctionType_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const FunctionType::type& val); + +std::string to_string(const FunctionType::type& val); + +struct ResourceType { + enum type { + JAR = 1, + FILE = 2, + ARCHIVE = 3 + }; +}; + +extern const std::map _ResourceType_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const ResourceType::type& val); + +std::string to_string(const ResourceType::type& val); + +struct TxnType { + enum type { + DEFAULT = 0, + REPL_CREATED = 1, + READ_ONLY = 2, + COMPACTION = 3, + MATER_VIEW_REBUILD = 4, + SOFT_DELETE = 5, + REBALANCE_COMPACTION = 6 + }; +}; + +extern const std::map _TxnType_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const TxnType::type& val); + +std::string to_string(const TxnType::type& val); + +struct GetTablesExtRequestFields { + enum type { + ACCESS_TYPE = 1, + PROCESSOR_CAPABILITIES = 2, + ALL = 2147483647 + }; +}; + +extern const std::map _GetTablesExtRequestFields_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const GetTablesExtRequestFields::type& val); + +std::string to_string(const GetTablesExtRequestFields::type& val); + +struct CompactionMetricsMetricType { + enum type { + NUM_OBSOLETE_DELTAS = 0, + NUM_DELTAS = 1, + NUM_SMALL_DELTAS = 2 + }; +}; + +extern const std::map _CompactionMetricsMetricType_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const CompactionMetricsMetricType::type& val); + +std::string to_string(const CompactionMetricsMetricType::type& val); + +struct FileMetadataExprType { + enum type { + ORC_SARG = 1 + }; +}; + +extern const std::map _FileMetadataExprType_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const FileMetadataExprType::type& val); + +std::string to_string(const FileMetadataExprType::type& val); + +struct ClientCapability { + enum type { + TEST_CAPABILITY = 1, + INSERT_ONLY_TABLES = 2 + }; +}; + +extern const std::map _ClientCapability_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const ClientCapability::type& val); + +std::string to_string(const ClientCapability::type& val); + +struct WMResourcePlanStatus { + enum type { + ACTIVE = 1, + ENABLED = 2, + DISABLED = 3 + }; +}; + +extern const std::map _WMResourcePlanStatus_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const WMResourcePlanStatus::type& val); + +std::string to_string(const WMResourcePlanStatus::type& val); + +struct WMPoolSchedulingPolicy { + enum type { + FAIR = 1, + FIFO = 2 + }; +}; + +extern const std::map _WMPoolSchedulingPolicy_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const WMPoolSchedulingPolicy::type& val); + +std::string to_string(const WMPoolSchedulingPolicy::type& val); + +struct ScheduledQueryMaintenanceRequestType { + enum type { + CREATE = 1, + ALTER = 2, + DROP = 3 + }; +}; + +extern const std::map _ScheduledQueryMaintenanceRequestType_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const ScheduledQueryMaintenanceRequestType::type& val); + +std::string to_string(const ScheduledQueryMaintenanceRequestType::type& val); + +struct QueryState { + enum type { + INITED = 0, + EXECUTING = 1, + FAILED = 2, + FINISHED = 3, + TIMED_OUT = 4, + AUTO_DISABLED = 5 + }; +}; + +extern const std::map _QueryState_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const QueryState::type& val); + +std::string to_string(const QueryState::type& val); + +struct PartitionFilterMode { + enum type { + BY_NAMES = 0, + BY_VALUES = 1, + BY_EXPR = 2 + }; +}; + +extern const std::map _PartitionFilterMode_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const PartitionFilterMode::type& val); + +std::string to_string(const PartitionFilterMode::type& val); + +class Version; + +class FieldSchema; + +class EnvironmentContext; + +class SQLPrimaryKey; + +class SQLForeignKey; + +class SQLUniqueConstraint; + +class SQLNotNullConstraint; + +class SQLDefaultConstraint; + +class SQLCheckConstraint; + +class SQLAllTableConstraints; + +class Type; + +class PropertySetRequest; + +class PropertyGetRequest; + +class PropertyGetResponse; + +class HiveObjectRef; + +class PrivilegeGrantInfo; + +class HiveObjectPrivilege; + +class PrivilegeBag; + +class PrincipalPrivilegeSet; + +class GrantRevokePrivilegeRequest; + +class GrantRevokePrivilegeResponse; + +class TruncateTableRequest; + +class TruncateTableResponse; + +class Role; + +class RolePrincipalGrant; + +class GetRoleGrantsForPrincipalRequest; + +class GetRoleGrantsForPrincipalResponse; + +class GetPrincipalsInRoleRequest; + +class GetPrincipalsInRoleResponse; + +class GrantRevokeRoleRequest; + +class GrantRevokeRoleResponse; + +class Catalog; + +class CreateCatalogRequest; + +class AlterCatalogRequest; + +class GetCatalogRequest; + +class GetCatalogResponse; + +class GetCatalogsResponse; + +class DropCatalogRequest; + +class Database; + +class SerDeInfo; + +class Order; + +class SkewedInfo; + +class StorageDescriptor; + +class CreationMetadata; + +class BooleanColumnStatsData; + +class DoubleColumnStatsData; + +class LongColumnStatsData; + +class StringColumnStatsData; + +class BinaryColumnStatsData; + +class Decimal; + +class DecimalColumnStatsData; + +class Date; + +class DateColumnStatsData; + +class Timestamp; + +class TimestampColumnStatsData; + +class ColumnStatisticsData; + +class ColumnStatisticsObj; + +class ColumnStatisticsDesc; + +class ColumnStatistics; + +class FileMetadata; + +class ObjectDictionary; + +class Table; + +class SourceTable; + +class Partition; + +class PartitionWithoutSD; + +class PartitionSpecWithSharedSD; + +class PartitionListComposingSpec; + +class PartitionSpec; + +class AggrStats; + +class SetPartitionsStatsRequest; + +class SetPartitionsStatsResponse; + +class Schema; + +class PrimaryKeysRequest; + +class PrimaryKeysResponse; + +class ForeignKeysRequest; + +class ForeignKeysResponse; + +class UniqueConstraintsRequest; + +class UniqueConstraintsResponse; + +class NotNullConstraintsRequest; + +class NotNullConstraintsResponse; + +class DefaultConstraintsRequest; + +class DefaultConstraintsResponse; + +class CheckConstraintsRequest; + +class CheckConstraintsResponse; + +class AllTableConstraintsRequest; + +class AllTableConstraintsResponse; + +class DropConstraintRequest; + +class AddPrimaryKeyRequest; + +class AddForeignKeyRequest; + +class AddUniqueConstraintRequest; + +class AddNotNullConstraintRequest; + +class AddDefaultConstraintRequest; + +class AddCheckConstraintRequest; + +class PartitionsByExprResult; + +class PartitionsSpecByExprResult; + +class PartitionsByExprRequest; + +class TableStatsResult; + +class PartitionsStatsResult; + +class TableStatsRequest; + +class PartitionsStatsRequest; + +class AddPartitionsResult; + +class AddPartitionsRequest; + +class DropPartitionsResult; + +class DropPartitionsExpr; + +class RequestPartsSpec; + +class DropPartitionsRequest; + +class DropPartitionRequest; + +class PartitionValuesRequest; + +class PartitionValuesRow; + +class PartitionValuesResponse; + +class GetPartitionsByNamesRequest; + +class GetPartitionsByNamesResult; + +class DataConnector; + +class ResourceUri; + +class Function; + +class TxnInfo; + +class GetOpenTxnsInfoResponse; + +class GetOpenTxnsResponse; + +class OpenTxnRequest; + +class OpenTxnsResponse; + +class AbortTxnRequest; + +class AbortTxnsRequest; + +class CommitTxnKeyValue; + +class WriteEventInfo; + +class ReplLastIdInfo; + +class UpdateTransactionalStatsRequest; + +class CommitTxnRequest; + +class ReplTblWriteIdStateRequest; + +class GetValidWriteIdsRequest; + +class TableValidWriteIds; + +class GetValidWriteIdsResponse; + +class TxnToWriteId; + +class AllocateTableWriteIdsRequest; + +class AllocateTableWriteIdsResponse; + +class MaxAllocatedTableWriteIdRequest; + +class MaxAllocatedTableWriteIdResponse; + +class SeedTableWriteIdsRequest; + +class SeedTxnIdRequest; + +class LockComponent; + +class LockRequest; + +class LockResponse; + +class CheckLockRequest; + +class UnlockRequest; + +class ShowLocksRequest; + +class ShowLocksResponseElement; + +class ShowLocksResponse; + +class HeartbeatRequest; + +class HeartbeatTxnRangeRequest; + +class HeartbeatTxnRangeResponse; + +class CompactionRequest; + +class CompactionInfoStruct; + +class OptionalCompactionInfoStruct; + +class CompactionMetricsDataStruct; + +class CompactionMetricsDataResponse; + +class CompactionMetricsDataRequest; + +class CompactionResponse; + +class ShowCompactRequest; + +class ShowCompactResponseElement; + +class ShowCompactResponse; + +class AbortCompactionRequest; + +class AbortCompactionResponseElement; + +class AbortCompactResponse; + +class GetLatestCommittedCompactionInfoRequest; + +class GetLatestCommittedCompactionInfoResponse; + +class FindNextCompactRequest; + +class AddDynamicPartitions; + +class BasicTxnInfo; + +class NotificationEventRequest; + +class NotificationEvent; + +class NotificationEventResponse; + +class CurrentNotificationEventId; + +class NotificationEventsCountRequest; + +class NotificationEventsCountResponse; + +class InsertEventRequestData; + +class FireEventRequestData; + +class FireEventRequest; + +class FireEventResponse; + +class WriteNotificationLogRequest; + +class WriteNotificationLogResponse; + +class WriteNotificationLogBatchRequest; + +class WriteNotificationLogBatchResponse; + +class MetadataPpdResult; + +class GetFileMetadataByExprResult; + +class GetFileMetadataByExprRequest; + +class GetFileMetadataResult; + +class GetFileMetadataRequest; + +class PutFileMetadataResult; + +class PutFileMetadataRequest; + +class ClearFileMetadataResult; + +class ClearFileMetadataRequest; + +class CacheFileMetadataResult; + +class CacheFileMetadataRequest; + +class GetAllFunctionsResponse; + +class ClientCapabilities; + +class GetProjectionsSpec; + +class GetTableRequest; + +class GetTableResult; + +class GetTablesRequest; + +class GetTablesResult; + +class GetTablesExtRequest; + +class ExtendedTableInfo; + +class DropTableRequest; + +class GetDatabaseRequest; + +class AlterDatabaseRequest; + +class DropDatabaseRequest; + +class CmRecycleRequest; + +class CmRecycleResponse; + +class TableMeta; + +class Materialization; + +class WMResourcePlan; + +class WMNullableResourcePlan; + +class WMPool; + +class WMNullablePool; + +class WMTrigger; + +class WMMapping; + +class WMPoolTrigger; + +class WMFullResourcePlan; + +class WMCreateResourcePlanRequest; + +class WMCreateResourcePlanResponse; + +class WMGetActiveResourcePlanRequest; + +class WMGetActiveResourcePlanResponse; + +class WMGetResourcePlanRequest; + +class WMGetResourcePlanResponse; + +class WMGetAllResourcePlanRequest; + +class WMGetAllResourcePlanResponse; + +class WMAlterResourcePlanRequest; + +class WMAlterResourcePlanResponse; + +class WMValidateResourcePlanRequest; + +class WMValidateResourcePlanResponse; + +class WMDropResourcePlanRequest; + +class WMDropResourcePlanResponse; + +class WMCreateTriggerRequest; + +class WMCreateTriggerResponse; + +class WMAlterTriggerRequest; + +class WMAlterTriggerResponse; + +class WMDropTriggerRequest; + +class WMDropTriggerResponse; + +class WMGetTriggersForResourePlanRequest; + +class WMGetTriggersForResourePlanResponse; + +class WMCreatePoolRequest; + +class WMCreatePoolResponse; + +class WMAlterPoolRequest; + +class WMAlterPoolResponse; + +class WMDropPoolRequest; + +class WMDropPoolResponse; + +class WMCreateOrUpdateMappingRequest; + +class WMCreateOrUpdateMappingResponse; + +class WMDropMappingRequest; + +class WMDropMappingResponse; + +class WMCreateOrDropTriggerToPoolMappingRequest; + +class WMCreateOrDropTriggerToPoolMappingResponse; + +class ISchema; + +class ISchemaName; + +class AlterISchemaRequest; + +class SchemaVersion; + +class SchemaVersionDescriptor; + +class FindSchemasByColsRqst; + +class FindSchemasByColsResp; + +class MapSchemaVersionToSerdeRequest; + +class SetSchemaVersionStateRequest; + +class GetSerdeRequest; + +class RuntimeStat; + +class GetRuntimeStatsRequest; + +class CreateTableRequest; + +class CreateDatabaseRequest; + +class CreateDataConnectorRequest; + +class GetDataConnectorRequest; + +class AlterDataConnectorRequest; + +class DropDataConnectorRequest; + +class ScheduledQueryPollRequest; + +class ScheduledQueryKey; + +class ScheduledQueryPollResponse; + +class ScheduledQuery; + +class ScheduledQueryMaintenanceRequest; + +class ScheduledQueryProgressInfo; + +class AlterPartitionsRequest; + +class AppendPartitionsRequest; + +class AlterPartitionsResponse; + +class RenamePartitionRequest; + +class RenamePartitionResponse; + +class AlterTableRequest; + +class AlterTableResponse; + +class GetPartitionsFilterSpec; + +class GetPartitionsResponse; + +class GetPartitionsRequest; + +class GetFieldsRequest; + +class GetFieldsResponse; + +class GetSchemaRequest; + +class GetSchemaResponse; + +class GetPartitionRequest; + +class GetPartitionResponse; + +class PartitionsRequest; + +class PartitionsResponse; + +class GetPartitionsByFilterRequest; + +class GetPartitionNamesPsRequest; + +class GetPartitionNamesPsResponse; + +class GetPartitionsPsWithAuthRequest; + +class GetPartitionsPsWithAuthResponse; + +class ReplicationMetrics; + +class ReplicationMetricList; + +class GetReplicationMetricsRequest; + +class GetOpenTxnsRequest; + +class StoredProcedureRequest; + +class ListStoredProcedureRequest; + +class StoredProcedure; + +class AddPackageRequest; + +class GetPackageRequest; + +class DropPackageRequest; + +class ListPackageRequest; + +class Package; + +class GetAllWriteEventInfoRequest; + +class MetaException; + +class UnknownTableException; + +class UnknownDBException; + +class AlreadyExistsException; + +class InvalidPartitionException; + +class UnknownPartitionException; + +class InvalidObjectException; + +class NoSuchObjectException; + +class InvalidOperationException; + +class ConfigValSecurityException; + +class InvalidInputException; + +class NoSuchTxnException; + +class TxnAbortedException; + +class TxnOpenException; + +class NoSuchLockException; + +class CompactionAbortedException; + +class NoSuchCompactionException; + +typedef struct _Version__isset { + _Version__isset() : version(false), comments(false) {} + bool version :1; + bool comments :1; +} _Version__isset; + +class Version : public virtual ::apache::thrift::TBase { + public: + + Version(const Version&); + Version& operator=(const Version&); + Version() noexcept; + + virtual ~Version() noexcept; + std::string version; + std::string comments; + + _Version__isset __isset; + + void __set_version(const std::string& val); + + void __set_comments(const std::string& val); + + bool operator == (const Version & rhs) const; + bool operator != (const Version &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Version & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Version &a, Version &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const Version& obj); + +typedef struct _FieldSchema__isset { + _FieldSchema__isset() : name(false), type(false), comment(false) {} + bool name :1; + bool type :1; + bool comment :1; +} _FieldSchema__isset; + +class FieldSchema : public virtual ::apache::thrift::TBase { + public: + + FieldSchema(const FieldSchema&); + FieldSchema& operator=(const FieldSchema&); + FieldSchema() noexcept; + + virtual ~FieldSchema() noexcept; + std::string name; + std::string type; + std::string comment; + + _FieldSchema__isset __isset; + + void __set_name(const std::string& val); + + void __set_type(const std::string& val); + + void __set_comment(const std::string& val); + + bool operator == (const FieldSchema & rhs) const; + bool operator != (const FieldSchema &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FieldSchema & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(FieldSchema &a, FieldSchema &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const FieldSchema& obj); + +typedef struct _EnvironmentContext__isset { + _EnvironmentContext__isset() : properties(false) {} + bool properties :1; +} _EnvironmentContext__isset; + +class EnvironmentContext : public virtual ::apache::thrift::TBase { + public: + + EnvironmentContext(const EnvironmentContext&); + EnvironmentContext& operator=(const EnvironmentContext&); + EnvironmentContext() noexcept; + + virtual ~EnvironmentContext() noexcept; + std::map properties; + + _EnvironmentContext__isset __isset; + + void __set_properties(const std::map & val); + + bool operator == (const EnvironmentContext & rhs) const; + bool operator != (const EnvironmentContext &rhs) const { + return !(*this == rhs); + } + + bool operator < (const EnvironmentContext & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(EnvironmentContext &a, EnvironmentContext &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const EnvironmentContext& obj); + +typedef struct _SQLPrimaryKey__isset { + _SQLPrimaryKey__isset() : table_db(false), table_name(false), column_name(false), key_seq(false), pk_name(false), enable_cstr(false), validate_cstr(false), rely_cstr(false), catName(false) {} + bool table_db :1; + bool table_name :1; + bool column_name :1; + bool key_seq :1; + bool pk_name :1; + bool enable_cstr :1; + bool validate_cstr :1; + bool rely_cstr :1; + bool catName :1; +} _SQLPrimaryKey__isset; + +class SQLPrimaryKey : public virtual ::apache::thrift::TBase { + public: + + SQLPrimaryKey(const SQLPrimaryKey&); + SQLPrimaryKey& operator=(const SQLPrimaryKey&); + SQLPrimaryKey() noexcept; + + virtual ~SQLPrimaryKey() noexcept; + std::string table_db; + std::string table_name; + std::string column_name; + int32_t key_seq; + std::string pk_name; + bool enable_cstr; + bool validate_cstr; + bool rely_cstr; + std::string catName; + + _SQLPrimaryKey__isset __isset; + + void __set_table_db(const std::string& val); + + void __set_table_name(const std::string& val); + + void __set_column_name(const std::string& val); + + void __set_key_seq(const int32_t val); + + void __set_pk_name(const std::string& val); + + void __set_enable_cstr(const bool val); + + void __set_validate_cstr(const bool val); + + void __set_rely_cstr(const bool val); + + void __set_catName(const std::string& val); + + bool operator == (const SQLPrimaryKey & rhs) const; + bool operator != (const SQLPrimaryKey &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SQLPrimaryKey & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(SQLPrimaryKey &a, SQLPrimaryKey &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const SQLPrimaryKey& obj); + +typedef struct _SQLForeignKey__isset { + _SQLForeignKey__isset() : pktable_db(false), pktable_name(false), pkcolumn_name(false), fktable_db(false), fktable_name(false), fkcolumn_name(false), key_seq(false), update_rule(false), delete_rule(false), fk_name(false), pk_name(false), enable_cstr(false), validate_cstr(false), rely_cstr(false), catName(false) {} + bool pktable_db :1; + bool pktable_name :1; + bool pkcolumn_name :1; + bool fktable_db :1; + bool fktable_name :1; + bool fkcolumn_name :1; + bool key_seq :1; + bool update_rule :1; + bool delete_rule :1; + bool fk_name :1; + bool pk_name :1; + bool enable_cstr :1; + bool validate_cstr :1; + bool rely_cstr :1; + bool catName :1; +} _SQLForeignKey__isset; + +class SQLForeignKey : public virtual ::apache::thrift::TBase { + public: + + SQLForeignKey(const SQLForeignKey&); + SQLForeignKey& operator=(const SQLForeignKey&); + SQLForeignKey() noexcept; + + virtual ~SQLForeignKey() noexcept; + std::string pktable_db; + std::string pktable_name; + std::string pkcolumn_name; + std::string fktable_db; + std::string fktable_name; + std::string fkcolumn_name; + int32_t key_seq; + int32_t update_rule; + int32_t delete_rule; + std::string fk_name; + std::string pk_name; + bool enable_cstr; + bool validate_cstr; + bool rely_cstr; + std::string catName; + + _SQLForeignKey__isset __isset; + + void __set_pktable_db(const std::string& val); + + void __set_pktable_name(const std::string& val); + + void __set_pkcolumn_name(const std::string& val); + + void __set_fktable_db(const std::string& val); + + void __set_fktable_name(const std::string& val); + + void __set_fkcolumn_name(const std::string& val); + + void __set_key_seq(const int32_t val); + + void __set_update_rule(const int32_t val); + + void __set_delete_rule(const int32_t val); + + void __set_fk_name(const std::string& val); + + void __set_pk_name(const std::string& val); + + void __set_enable_cstr(const bool val); + + void __set_validate_cstr(const bool val); + + void __set_rely_cstr(const bool val); + + void __set_catName(const std::string& val); + + bool operator == (const SQLForeignKey & rhs) const; + bool operator != (const SQLForeignKey &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SQLForeignKey & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(SQLForeignKey &a, SQLForeignKey &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const SQLForeignKey& obj); + +typedef struct _SQLUniqueConstraint__isset { + _SQLUniqueConstraint__isset() : catName(false), table_db(false), table_name(false), column_name(false), key_seq(false), uk_name(false), enable_cstr(false), validate_cstr(false), rely_cstr(false) {} + bool catName :1; + bool table_db :1; + bool table_name :1; + bool column_name :1; + bool key_seq :1; + bool uk_name :1; + bool enable_cstr :1; + bool validate_cstr :1; + bool rely_cstr :1; +} _SQLUniqueConstraint__isset; + +class SQLUniqueConstraint : public virtual ::apache::thrift::TBase { + public: + + SQLUniqueConstraint(const SQLUniqueConstraint&); + SQLUniqueConstraint& operator=(const SQLUniqueConstraint&); + SQLUniqueConstraint() noexcept; + + virtual ~SQLUniqueConstraint() noexcept; + std::string catName; + std::string table_db; + std::string table_name; + std::string column_name; + int32_t key_seq; + std::string uk_name; + bool enable_cstr; + bool validate_cstr; + bool rely_cstr; + + _SQLUniqueConstraint__isset __isset; + + void __set_catName(const std::string& val); + + void __set_table_db(const std::string& val); + + void __set_table_name(const std::string& val); + + void __set_column_name(const std::string& val); + + void __set_key_seq(const int32_t val); + + void __set_uk_name(const std::string& val); + + void __set_enable_cstr(const bool val); + + void __set_validate_cstr(const bool val); + + void __set_rely_cstr(const bool val); + + bool operator == (const SQLUniqueConstraint & rhs) const; + bool operator != (const SQLUniqueConstraint &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SQLUniqueConstraint & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(SQLUniqueConstraint &a, SQLUniqueConstraint &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const SQLUniqueConstraint& obj); + +typedef struct _SQLNotNullConstraint__isset { + _SQLNotNullConstraint__isset() : catName(false), table_db(false), table_name(false), column_name(false), nn_name(false), enable_cstr(false), validate_cstr(false), rely_cstr(false) {} + bool catName :1; + bool table_db :1; + bool table_name :1; + bool column_name :1; + bool nn_name :1; + bool enable_cstr :1; + bool validate_cstr :1; + bool rely_cstr :1; +} _SQLNotNullConstraint__isset; + +class SQLNotNullConstraint : public virtual ::apache::thrift::TBase { + public: + + SQLNotNullConstraint(const SQLNotNullConstraint&); + SQLNotNullConstraint& operator=(const SQLNotNullConstraint&); + SQLNotNullConstraint() noexcept; + + virtual ~SQLNotNullConstraint() noexcept; + std::string catName; + std::string table_db; + std::string table_name; + std::string column_name; + std::string nn_name; + bool enable_cstr; + bool validate_cstr; + bool rely_cstr; + + _SQLNotNullConstraint__isset __isset; + + void __set_catName(const std::string& val); + + void __set_table_db(const std::string& val); + + void __set_table_name(const std::string& val); + + void __set_column_name(const std::string& val); + + void __set_nn_name(const std::string& val); + + void __set_enable_cstr(const bool val); + + void __set_validate_cstr(const bool val); + + void __set_rely_cstr(const bool val); + + bool operator == (const SQLNotNullConstraint & rhs) const; + bool operator != (const SQLNotNullConstraint &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SQLNotNullConstraint & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(SQLNotNullConstraint &a, SQLNotNullConstraint &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const SQLNotNullConstraint& obj); + +typedef struct _SQLDefaultConstraint__isset { + _SQLDefaultConstraint__isset() : catName(false), table_db(false), table_name(false), column_name(false), default_value(false), dc_name(false), enable_cstr(false), validate_cstr(false), rely_cstr(false) {} + bool catName :1; + bool table_db :1; + bool table_name :1; + bool column_name :1; + bool default_value :1; + bool dc_name :1; + bool enable_cstr :1; + bool validate_cstr :1; + bool rely_cstr :1; +} _SQLDefaultConstraint__isset; + +class SQLDefaultConstraint : public virtual ::apache::thrift::TBase { + public: + + SQLDefaultConstraint(const SQLDefaultConstraint&); + SQLDefaultConstraint& operator=(const SQLDefaultConstraint&); + SQLDefaultConstraint() noexcept; + + virtual ~SQLDefaultConstraint() noexcept; + std::string catName; + std::string table_db; + std::string table_name; + std::string column_name; + std::string default_value; + std::string dc_name; + bool enable_cstr; + bool validate_cstr; + bool rely_cstr; + + _SQLDefaultConstraint__isset __isset; + + void __set_catName(const std::string& val); + + void __set_table_db(const std::string& val); + + void __set_table_name(const std::string& val); + + void __set_column_name(const std::string& val); + + void __set_default_value(const std::string& val); + + void __set_dc_name(const std::string& val); + + void __set_enable_cstr(const bool val); + + void __set_validate_cstr(const bool val); + + void __set_rely_cstr(const bool val); + + bool operator == (const SQLDefaultConstraint & rhs) const; + bool operator != (const SQLDefaultConstraint &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SQLDefaultConstraint & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(SQLDefaultConstraint &a, SQLDefaultConstraint &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const SQLDefaultConstraint& obj); + +typedef struct _SQLCheckConstraint__isset { + _SQLCheckConstraint__isset() : catName(false), table_db(false), table_name(false), column_name(false), check_expression(false), dc_name(false), enable_cstr(false), validate_cstr(false), rely_cstr(false) {} + bool catName :1; + bool table_db :1; + bool table_name :1; + bool column_name :1; + bool check_expression :1; + bool dc_name :1; + bool enable_cstr :1; + bool validate_cstr :1; + bool rely_cstr :1; +} _SQLCheckConstraint__isset; + +class SQLCheckConstraint : public virtual ::apache::thrift::TBase { + public: + + SQLCheckConstraint(const SQLCheckConstraint&); + SQLCheckConstraint& operator=(const SQLCheckConstraint&); + SQLCheckConstraint() noexcept; + + virtual ~SQLCheckConstraint() noexcept; + std::string catName; + std::string table_db; + std::string table_name; + std::string column_name; + std::string check_expression; + std::string dc_name; + bool enable_cstr; + bool validate_cstr; + bool rely_cstr; + + _SQLCheckConstraint__isset __isset; + + void __set_catName(const std::string& val); + + void __set_table_db(const std::string& val); + + void __set_table_name(const std::string& val); + + void __set_column_name(const std::string& val); + + void __set_check_expression(const std::string& val); + + void __set_dc_name(const std::string& val); + + void __set_enable_cstr(const bool val); + + void __set_validate_cstr(const bool val); + + void __set_rely_cstr(const bool val); + + bool operator == (const SQLCheckConstraint & rhs) const; + bool operator != (const SQLCheckConstraint &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SQLCheckConstraint & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(SQLCheckConstraint &a, SQLCheckConstraint &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const SQLCheckConstraint& obj); + +typedef struct _SQLAllTableConstraints__isset { + _SQLAllTableConstraints__isset() : primaryKeys(false), foreignKeys(false), uniqueConstraints(false), notNullConstraints(false), defaultConstraints(false), checkConstraints(false) {} + bool primaryKeys :1; + bool foreignKeys :1; + bool uniqueConstraints :1; + bool notNullConstraints :1; + bool defaultConstraints :1; + bool checkConstraints :1; +} _SQLAllTableConstraints__isset; + +class SQLAllTableConstraints : public virtual ::apache::thrift::TBase { + public: + + SQLAllTableConstraints(const SQLAllTableConstraints&); + SQLAllTableConstraints& operator=(const SQLAllTableConstraints&); + SQLAllTableConstraints() noexcept; + + virtual ~SQLAllTableConstraints() noexcept; + std::vector primaryKeys; + std::vector foreignKeys; + std::vector uniqueConstraints; + std::vector notNullConstraints; + std::vector defaultConstraints; + std::vector checkConstraints; + + _SQLAllTableConstraints__isset __isset; + + void __set_primaryKeys(const std::vector & val); + + void __set_foreignKeys(const std::vector & val); + + void __set_uniqueConstraints(const std::vector & val); + + void __set_notNullConstraints(const std::vector & val); + + void __set_defaultConstraints(const std::vector & val); + + void __set_checkConstraints(const std::vector & val); + + bool operator == (const SQLAllTableConstraints & rhs) const; + bool operator != (const SQLAllTableConstraints &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SQLAllTableConstraints & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(SQLAllTableConstraints &a, SQLAllTableConstraints &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const SQLAllTableConstraints& obj); + +typedef struct _Type__isset { + _Type__isset() : name(false), type1(false), type2(false), fields(false) {} + bool name :1; + bool type1 :1; + bool type2 :1; + bool fields :1; +} _Type__isset; + +class Type : public virtual ::apache::thrift::TBase { + public: + + Type(const Type&); + Type& operator=(const Type&); + Type() noexcept; + + virtual ~Type() noexcept; + std::string name; + std::string type1; + std::string type2; + std::vector fields; + + _Type__isset __isset; + + void __set_name(const std::string& val); + + void __set_type1(const std::string& val); + + void __set_type2(const std::string& val); + + void __set_fields(const std::vector & val); + + bool operator == (const Type & rhs) const; + bool operator != (const Type &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Type & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Type &a, Type &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const Type& obj); + +typedef struct _PropertySetRequest__isset { + _PropertySetRequest__isset() : propertyMap(false) {} + bool propertyMap :1; +} _PropertySetRequest__isset; + +class PropertySetRequest : public virtual ::apache::thrift::TBase { + public: + + PropertySetRequest(const PropertySetRequest&); + PropertySetRequest& operator=(const PropertySetRequest&); + PropertySetRequest() noexcept; + + virtual ~PropertySetRequest() noexcept; + std::string nameSpace; + std::map propertyMap; + + _PropertySetRequest__isset __isset; + + void __set_nameSpace(const std::string& val); + + void __set_propertyMap(const std::map & val); + + bool operator == (const PropertySetRequest & rhs) const; + bool operator != (const PropertySetRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PropertySetRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PropertySetRequest &a, PropertySetRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PropertySetRequest& obj); + +typedef struct _PropertyGetRequest__isset { + _PropertyGetRequest__isset() : mapPrefix(false), mapPredicate(false), mapSelection(false) {} + bool mapPrefix :1; + bool mapPredicate :1; + bool mapSelection :1; +} _PropertyGetRequest__isset; + +class PropertyGetRequest : public virtual ::apache::thrift::TBase { + public: + + PropertyGetRequest(const PropertyGetRequest&); + PropertyGetRequest& operator=(const PropertyGetRequest&); + PropertyGetRequest() noexcept; + + virtual ~PropertyGetRequest() noexcept; + std::string nameSpace; + std::string mapPrefix; + std::string mapPredicate; + std::vector mapSelection; + + _PropertyGetRequest__isset __isset; + + void __set_nameSpace(const std::string& val); + + void __set_mapPrefix(const std::string& val); + + void __set_mapPredicate(const std::string& val); + + void __set_mapSelection(const std::vector & val); + + bool operator == (const PropertyGetRequest & rhs) const; + bool operator != (const PropertyGetRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PropertyGetRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PropertyGetRequest &a, PropertyGetRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PropertyGetRequest& obj); + +typedef struct _PropertyGetResponse__isset { + _PropertyGetResponse__isset() : properties(false) {} + bool properties :1; +} _PropertyGetResponse__isset; + +class PropertyGetResponse : public virtual ::apache::thrift::TBase { + public: + + PropertyGetResponse(const PropertyGetResponse&); + PropertyGetResponse& operator=(const PropertyGetResponse&); + PropertyGetResponse() noexcept; + + virtual ~PropertyGetResponse() noexcept; + std::map > properties; + + _PropertyGetResponse__isset __isset; + + void __set_properties(const std::map > & val); + + bool operator == (const PropertyGetResponse & rhs) const; + bool operator != (const PropertyGetResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PropertyGetResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PropertyGetResponse &a, PropertyGetResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PropertyGetResponse& obj); + +typedef struct _HiveObjectRef__isset { + _HiveObjectRef__isset() : objectType(false), dbName(false), objectName(false), partValues(false), columnName(false), catName(false) {} + bool objectType :1; + bool dbName :1; + bool objectName :1; + bool partValues :1; + bool columnName :1; + bool catName :1; +} _HiveObjectRef__isset; + +class HiveObjectRef : public virtual ::apache::thrift::TBase { + public: + + HiveObjectRef(const HiveObjectRef&); + HiveObjectRef& operator=(const HiveObjectRef&); + HiveObjectRef() noexcept; + + virtual ~HiveObjectRef() noexcept; + /** + * + * @see HiveObjectType + */ + HiveObjectType::type objectType; + std::string dbName; + std::string objectName; + std::vector partValues; + std::string columnName; + std::string catName; + + _HiveObjectRef__isset __isset; + + void __set_objectType(const HiveObjectType::type val); + + void __set_dbName(const std::string& val); + + void __set_objectName(const std::string& val); + + void __set_partValues(const std::vector & val); + + void __set_columnName(const std::string& val); + + void __set_catName(const std::string& val); + + bool operator == (const HiveObjectRef & rhs) const; + bool operator != (const HiveObjectRef &rhs) const { + return !(*this == rhs); + } + + bool operator < (const HiveObjectRef & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(HiveObjectRef &a, HiveObjectRef &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const HiveObjectRef& obj); + +typedef struct _PrivilegeGrantInfo__isset { + _PrivilegeGrantInfo__isset() : privilege(false), createTime(false), grantor(false), grantorType(false), grantOption(false) {} + bool privilege :1; + bool createTime :1; + bool grantor :1; + bool grantorType :1; + bool grantOption :1; +} _PrivilegeGrantInfo__isset; + +class PrivilegeGrantInfo : public virtual ::apache::thrift::TBase { + public: + + PrivilegeGrantInfo(const PrivilegeGrantInfo&); + PrivilegeGrantInfo& operator=(const PrivilegeGrantInfo&); + PrivilegeGrantInfo() noexcept; + + virtual ~PrivilegeGrantInfo() noexcept; + std::string privilege; + int32_t createTime; + std::string grantor; + /** + * + * @see PrincipalType + */ + PrincipalType::type grantorType; + bool grantOption; + + _PrivilegeGrantInfo__isset __isset; + + void __set_privilege(const std::string& val); + + void __set_createTime(const int32_t val); + + void __set_grantor(const std::string& val); + + void __set_grantorType(const PrincipalType::type val); + + void __set_grantOption(const bool val); + + bool operator == (const PrivilegeGrantInfo & rhs) const; + bool operator != (const PrivilegeGrantInfo &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PrivilegeGrantInfo & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PrivilegeGrantInfo &a, PrivilegeGrantInfo &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PrivilegeGrantInfo& obj); + +typedef struct _HiveObjectPrivilege__isset { + _HiveObjectPrivilege__isset() : hiveObject(false), principalName(false), principalType(false), grantInfo(false), authorizer(false) {} + bool hiveObject :1; + bool principalName :1; + bool principalType :1; + bool grantInfo :1; + bool authorizer :1; +} _HiveObjectPrivilege__isset; + +class HiveObjectPrivilege : public virtual ::apache::thrift::TBase { + public: + + HiveObjectPrivilege(const HiveObjectPrivilege&); + HiveObjectPrivilege& operator=(const HiveObjectPrivilege&); + HiveObjectPrivilege() noexcept; + + virtual ~HiveObjectPrivilege() noexcept; + HiveObjectRef hiveObject; + std::string principalName; + /** + * + * @see PrincipalType + */ + PrincipalType::type principalType; + PrivilegeGrantInfo grantInfo; + std::string authorizer; + + _HiveObjectPrivilege__isset __isset; + + void __set_hiveObject(const HiveObjectRef& val); + + void __set_principalName(const std::string& val); + + void __set_principalType(const PrincipalType::type val); + + void __set_grantInfo(const PrivilegeGrantInfo& val); + + void __set_authorizer(const std::string& val); + + bool operator == (const HiveObjectPrivilege & rhs) const; + bool operator != (const HiveObjectPrivilege &rhs) const { + return !(*this == rhs); + } + + bool operator < (const HiveObjectPrivilege & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(HiveObjectPrivilege &a, HiveObjectPrivilege &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const HiveObjectPrivilege& obj); + +typedef struct _PrivilegeBag__isset { + _PrivilegeBag__isset() : privileges(false) {} + bool privileges :1; +} _PrivilegeBag__isset; + +class PrivilegeBag : public virtual ::apache::thrift::TBase { + public: + + PrivilegeBag(const PrivilegeBag&); + PrivilegeBag& operator=(const PrivilegeBag&); + PrivilegeBag() noexcept; + + virtual ~PrivilegeBag() noexcept; + std::vector privileges; + + _PrivilegeBag__isset __isset; + + void __set_privileges(const std::vector & val); + + bool operator == (const PrivilegeBag & rhs) const; + bool operator != (const PrivilegeBag &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PrivilegeBag & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PrivilegeBag &a, PrivilegeBag &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PrivilegeBag& obj); + +typedef struct _PrincipalPrivilegeSet__isset { + _PrincipalPrivilegeSet__isset() : userPrivileges(false), groupPrivileges(false), rolePrivileges(false) {} + bool userPrivileges :1; + bool groupPrivileges :1; + bool rolePrivileges :1; +} _PrincipalPrivilegeSet__isset; + +class PrincipalPrivilegeSet : public virtual ::apache::thrift::TBase { + public: + + PrincipalPrivilegeSet(const PrincipalPrivilegeSet&); + PrincipalPrivilegeSet& operator=(const PrincipalPrivilegeSet&); + PrincipalPrivilegeSet() noexcept; + + virtual ~PrincipalPrivilegeSet() noexcept; + std::map > userPrivileges; + std::map > groupPrivileges; + std::map > rolePrivileges; + + _PrincipalPrivilegeSet__isset __isset; + + void __set_userPrivileges(const std::map > & val); + + void __set_groupPrivileges(const std::map > & val); + + void __set_rolePrivileges(const std::map > & val); + + bool operator == (const PrincipalPrivilegeSet & rhs) const; + bool operator != (const PrincipalPrivilegeSet &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PrincipalPrivilegeSet & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PrincipalPrivilegeSet &a, PrincipalPrivilegeSet &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PrincipalPrivilegeSet& obj); + +typedef struct _GrantRevokePrivilegeRequest__isset { + _GrantRevokePrivilegeRequest__isset() : requestType(false), privileges(false), revokeGrantOption(false) {} + bool requestType :1; + bool privileges :1; + bool revokeGrantOption :1; +} _GrantRevokePrivilegeRequest__isset; + +class GrantRevokePrivilegeRequest : public virtual ::apache::thrift::TBase { + public: + + GrantRevokePrivilegeRequest(const GrantRevokePrivilegeRequest&); + GrantRevokePrivilegeRequest& operator=(const GrantRevokePrivilegeRequest&); + GrantRevokePrivilegeRequest() noexcept; + + virtual ~GrantRevokePrivilegeRequest() noexcept; + /** + * + * @see GrantRevokeType + */ + GrantRevokeType::type requestType; + PrivilegeBag privileges; + bool revokeGrantOption; + + _GrantRevokePrivilegeRequest__isset __isset; + + void __set_requestType(const GrantRevokeType::type val); + + void __set_privileges(const PrivilegeBag& val); + + void __set_revokeGrantOption(const bool val); + + bool operator == (const GrantRevokePrivilegeRequest & rhs) const; + bool operator != (const GrantRevokePrivilegeRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GrantRevokePrivilegeRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GrantRevokePrivilegeRequest &a, GrantRevokePrivilegeRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GrantRevokePrivilegeRequest& obj); + +typedef struct _GrantRevokePrivilegeResponse__isset { + _GrantRevokePrivilegeResponse__isset() : success(false) {} + bool success :1; +} _GrantRevokePrivilegeResponse__isset; + +class GrantRevokePrivilegeResponse : public virtual ::apache::thrift::TBase { + public: + + GrantRevokePrivilegeResponse(const GrantRevokePrivilegeResponse&) noexcept; + GrantRevokePrivilegeResponse& operator=(const GrantRevokePrivilegeResponse&) noexcept; + GrantRevokePrivilegeResponse() noexcept; + + virtual ~GrantRevokePrivilegeResponse() noexcept; + bool success; + + _GrantRevokePrivilegeResponse__isset __isset; + + void __set_success(const bool val); + + bool operator == (const GrantRevokePrivilegeResponse & rhs) const; + bool operator != (const GrantRevokePrivilegeResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GrantRevokePrivilegeResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GrantRevokePrivilegeResponse &a, GrantRevokePrivilegeResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GrantRevokePrivilegeResponse& obj); + +typedef struct _TruncateTableRequest__isset { + _TruncateTableRequest__isset() : partNames(false), writeId(true), validWriteIdList(false), environmentContext(false) {} + bool partNames :1; + bool writeId :1; + bool validWriteIdList :1; + bool environmentContext :1; +} _TruncateTableRequest__isset; + +class TruncateTableRequest : public virtual ::apache::thrift::TBase { + public: + + TruncateTableRequest(const TruncateTableRequest&); + TruncateTableRequest& operator=(const TruncateTableRequest&); + TruncateTableRequest() noexcept; + + virtual ~TruncateTableRequest() noexcept; + std::string dbName; + std::string tableName; + std::vector partNames; + int64_t writeId; + std::string validWriteIdList; + EnvironmentContext environmentContext; + + _TruncateTableRequest__isset __isset; + + void __set_dbName(const std::string& val); + + void __set_tableName(const std::string& val); + + void __set_partNames(const std::vector & val); + + void __set_writeId(const int64_t val); + + void __set_validWriteIdList(const std::string& val); + + void __set_environmentContext(const EnvironmentContext& val); + + bool operator == (const TruncateTableRequest & rhs) const; + bool operator != (const TruncateTableRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TruncateTableRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TruncateTableRequest &a, TruncateTableRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const TruncateTableRequest& obj); + + +class TruncateTableResponse : public virtual ::apache::thrift::TBase { + public: + + TruncateTableResponse(const TruncateTableResponse&) noexcept; + TruncateTableResponse& operator=(const TruncateTableResponse&) noexcept; + TruncateTableResponse() noexcept; + + virtual ~TruncateTableResponse() noexcept; + + bool operator == (const TruncateTableResponse & /* rhs */) const; + bool operator != (const TruncateTableResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TruncateTableResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TruncateTableResponse &a, TruncateTableResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const TruncateTableResponse& obj); + +typedef struct _Role__isset { + _Role__isset() : roleName(false), createTime(false), ownerName(false) {} + bool roleName :1; + bool createTime :1; + bool ownerName :1; +} _Role__isset; + +class Role : public virtual ::apache::thrift::TBase { + public: + + Role(const Role&); + Role& operator=(const Role&); + Role() noexcept; + + virtual ~Role() noexcept; + std::string roleName; + int32_t createTime; + std::string ownerName; + + _Role__isset __isset; + + void __set_roleName(const std::string& val); + + void __set_createTime(const int32_t val); + + void __set_ownerName(const std::string& val); + + bool operator == (const Role & rhs) const; + bool operator != (const Role &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Role & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Role &a, Role &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const Role& obj); + +typedef struct _RolePrincipalGrant__isset { + _RolePrincipalGrant__isset() : roleName(false), principalName(false), principalType(false), grantOption(false), grantTime(false), grantorName(false), grantorPrincipalType(false) {} + bool roleName :1; + bool principalName :1; + bool principalType :1; + bool grantOption :1; + bool grantTime :1; + bool grantorName :1; + bool grantorPrincipalType :1; +} _RolePrincipalGrant__isset; + +class RolePrincipalGrant : public virtual ::apache::thrift::TBase { + public: + + RolePrincipalGrant(const RolePrincipalGrant&); + RolePrincipalGrant& operator=(const RolePrincipalGrant&); + RolePrincipalGrant() noexcept; + + virtual ~RolePrincipalGrant() noexcept; + std::string roleName; + std::string principalName; + /** + * + * @see PrincipalType + */ + PrincipalType::type principalType; + bool grantOption; + int32_t grantTime; + std::string grantorName; + /** + * + * @see PrincipalType + */ + PrincipalType::type grantorPrincipalType; + + _RolePrincipalGrant__isset __isset; + + void __set_roleName(const std::string& val); + + void __set_principalName(const std::string& val); + + void __set_principalType(const PrincipalType::type val); + + void __set_grantOption(const bool val); + + void __set_grantTime(const int32_t val); + + void __set_grantorName(const std::string& val); + + void __set_grantorPrincipalType(const PrincipalType::type val); + + bool operator == (const RolePrincipalGrant & rhs) const; + bool operator != (const RolePrincipalGrant &rhs) const { + return !(*this == rhs); + } + + bool operator < (const RolePrincipalGrant & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(RolePrincipalGrant &a, RolePrincipalGrant &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const RolePrincipalGrant& obj); + + +class GetRoleGrantsForPrincipalRequest : public virtual ::apache::thrift::TBase { + public: + + GetRoleGrantsForPrincipalRequest(const GetRoleGrantsForPrincipalRequest&); + GetRoleGrantsForPrincipalRequest& operator=(const GetRoleGrantsForPrincipalRequest&); + GetRoleGrantsForPrincipalRequest() noexcept; + + virtual ~GetRoleGrantsForPrincipalRequest() noexcept; + std::string principal_name; + /** + * + * @see PrincipalType + */ + PrincipalType::type principal_type; + + void __set_principal_name(const std::string& val); + + void __set_principal_type(const PrincipalType::type val); + + bool operator == (const GetRoleGrantsForPrincipalRequest & rhs) const; + bool operator != (const GetRoleGrantsForPrincipalRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetRoleGrantsForPrincipalRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetRoleGrantsForPrincipalRequest &a, GetRoleGrantsForPrincipalRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetRoleGrantsForPrincipalRequest& obj); + + +class GetRoleGrantsForPrincipalResponse : public virtual ::apache::thrift::TBase { + public: + + GetRoleGrantsForPrincipalResponse(const GetRoleGrantsForPrincipalResponse&); + GetRoleGrantsForPrincipalResponse& operator=(const GetRoleGrantsForPrincipalResponse&); + GetRoleGrantsForPrincipalResponse() noexcept; + + virtual ~GetRoleGrantsForPrincipalResponse() noexcept; + std::vector principalGrants; + + void __set_principalGrants(const std::vector & val); + + bool operator == (const GetRoleGrantsForPrincipalResponse & rhs) const; + bool operator != (const GetRoleGrantsForPrincipalResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetRoleGrantsForPrincipalResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetRoleGrantsForPrincipalResponse &a, GetRoleGrantsForPrincipalResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetRoleGrantsForPrincipalResponse& obj); + + +class GetPrincipalsInRoleRequest : public virtual ::apache::thrift::TBase { + public: + + GetPrincipalsInRoleRequest(const GetPrincipalsInRoleRequest&); + GetPrincipalsInRoleRequest& operator=(const GetPrincipalsInRoleRequest&); + GetPrincipalsInRoleRequest() noexcept; + + virtual ~GetPrincipalsInRoleRequest() noexcept; + std::string roleName; + + void __set_roleName(const std::string& val); + + bool operator == (const GetPrincipalsInRoleRequest & rhs) const; + bool operator != (const GetPrincipalsInRoleRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetPrincipalsInRoleRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetPrincipalsInRoleRequest &a, GetPrincipalsInRoleRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetPrincipalsInRoleRequest& obj); + + +class GetPrincipalsInRoleResponse : public virtual ::apache::thrift::TBase { + public: + + GetPrincipalsInRoleResponse(const GetPrincipalsInRoleResponse&); + GetPrincipalsInRoleResponse& operator=(const GetPrincipalsInRoleResponse&); + GetPrincipalsInRoleResponse() noexcept; + + virtual ~GetPrincipalsInRoleResponse() noexcept; + std::vector principalGrants; + + void __set_principalGrants(const std::vector & val); + + bool operator == (const GetPrincipalsInRoleResponse & rhs) const; + bool operator != (const GetPrincipalsInRoleResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetPrincipalsInRoleResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetPrincipalsInRoleResponse &a, GetPrincipalsInRoleResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetPrincipalsInRoleResponse& obj); + +typedef struct _GrantRevokeRoleRequest__isset { + _GrantRevokeRoleRequest__isset() : requestType(false), roleName(false), principalName(false), principalType(false), grantor(false), grantorType(false), grantOption(false) {} + bool requestType :1; + bool roleName :1; + bool principalName :1; + bool principalType :1; + bool grantor :1; + bool grantorType :1; + bool grantOption :1; +} _GrantRevokeRoleRequest__isset; + +class GrantRevokeRoleRequest : public virtual ::apache::thrift::TBase { + public: + + GrantRevokeRoleRequest(const GrantRevokeRoleRequest&); + GrantRevokeRoleRequest& operator=(const GrantRevokeRoleRequest&); + GrantRevokeRoleRequest() noexcept; + + virtual ~GrantRevokeRoleRequest() noexcept; + /** + * + * @see GrantRevokeType + */ + GrantRevokeType::type requestType; + std::string roleName; + std::string principalName; + /** + * + * @see PrincipalType + */ + PrincipalType::type principalType; + std::string grantor; + /** + * + * @see PrincipalType + */ + PrincipalType::type grantorType; + bool grantOption; + + _GrantRevokeRoleRequest__isset __isset; + + void __set_requestType(const GrantRevokeType::type val); + + void __set_roleName(const std::string& val); + + void __set_principalName(const std::string& val); + + void __set_principalType(const PrincipalType::type val); + + void __set_grantor(const std::string& val); + + void __set_grantorType(const PrincipalType::type val); + + void __set_grantOption(const bool val); + + bool operator == (const GrantRevokeRoleRequest & rhs) const; + bool operator != (const GrantRevokeRoleRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GrantRevokeRoleRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GrantRevokeRoleRequest &a, GrantRevokeRoleRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GrantRevokeRoleRequest& obj); + +typedef struct _GrantRevokeRoleResponse__isset { + _GrantRevokeRoleResponse__isset() : success(false) {} + bool success :1; +} _GrantRevokeRoleResponse__isset; + +class GrantRevokeRoleResponse : public virtual ::apache::thrift::TBase { + public: + + GrantRevokeRoleResponse(const GrantRevokeRoleResponse&) noexcept; + GrantRevokeRoleResponse& operator=(const GrantRevokeRoleResponse&) noexcept; + GrantRevokeRoleResponse() noexcept; + + virtual ~GrantRevokeRoleResponse() noexcept; + bool success; + + _GrantRevokeRoleResponse__isset __isset; + + void __set_success(const bool val); + + bool operator == (const GrantRevokeRoleResponse & rhs) const; + bool operator != (const GrantRevokeRoleResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GrantRevokeRoleResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GrantRevokeRoleResponse &a, GrantRevokeRoleResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GrantRevokeRoleResponse& obj); + +typedef struct _Catalog__isset { + _Catalog__isset() : name(false), description(false), locationUri(false), createTime(false) {} + bool name :1; + bool description :1; + bool locationUri :1; + bool createTime :1; +} _Catalog__isset; + +class Catalog : public virtual ::apache::thrift::TBase { + public: + + Catalog(const Catalog&); + Catalog& operator=(const Catalog&); + Catalog() noexcept; + + virtual ~Catalog() noexcept; + std::string name; + std::string description; + std::string locationUri; + int32_t createTime; + + _Catalog__isset __isset; + + void __set_name(const std::string& val); + + void __set_description(const std::string& val); + + void __set_locationUri(const std::string& val); + + void __set_createTime(const int32_t val); + + bool operator == (const Catalog & rhs) const; + bool operator != (const Catalog &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Catalog & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Catalog &a, Catalog &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const Catalog& obj); + +typedef struct _CreateCatalogRequest__isset { + _CreateCatalogRequest__isset() : catalog(false) {} + bool catalog :1; +} _CreateCatalogRequest__isset; + +class CreateCatalogRequest : public virtual ::apache::thrift::TBase { + public: + + CreateCatalogRequest(const CreateCatalogRequest&); + CreateCatalogRequest& operator=(const CreateCatalogRequest&); + CreateCatalogRequest() noexcept; + + virtual ~CreateCatalogRequest() noexcept; + Catalog catalog; + + _CreateCatalogRequest__isset __isset; + + void __set_catalog(const Catalog& val); + + bool operator == (const CreateCatalogRequest & rhs) const; + bool operator != (const CreateCatalogRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CreateCatalogRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(CreateCatalogRequest &a, CreateCatalogRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const CreateCatalogRequest& obj); + +typedef struct _AlterCatalogRequest__isset { + _AlterCatalogRequest__isset() : name(false), newCat(false) {} + bool name :1; + bool newCat :1; +} _AlterCatalogRequest__isset; + +class AlterCatalogRequest : public virtual ::apache::thrift::TBase { + public: + + AlterCatalogRequest(const AlterCatalogRequest&); + AlterCatalogRequest& operator=(const AlterCatalogRequest&); + AlterCatalogRequest() noexcept; + + virtual ~AlterCatalogRequest() noexcept; + std::string name; + Catalog newCat; + + _AlterCatalogRequest__isset __isset; + + void __set_name(const std::string& val); + + void __set_newCat(const Catalog& val); + + bool operator == (const AlterCatalogRequest & rhs) const; + bool operator != (const AlterCatalogRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AlterCatalogRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AlterCatalogRequest &a, AlterCatalogRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AlterCatalogRequest& obj); + +typedef struct _GetCatalogRequest__isset { + _GetCatalogRequest__isset() : name(false) {} + bool name :1; +} _GetCatalogRequest__isset; + +class GetCatalogRequest : public virtual ::apache::thrift::TBase { + public: + + GetCatalogRequest(const GetCatalogRequest&); + GetCatalogRequest& operator=(const GetCatalogRequest&); + GetCatalogRequest() noexcept; + + virtual ~GetCatalogRequest() noexcept; + std::string name; + + _GetCatalogRequest__isset __isset; + + void __set_name(const std::string& val); + + bool operator == (const GetCatalogRequest & rhs) const; + bool operator != (const GetCatalogRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetCatalogRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetCatalogRequest &a, GetCatalogRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetCatalogRequest& obj); + +typedef struct _GetCatalogResponse__isset { + _GetCatalogResponse__isset() : catalog(false) {} + bool catalog :1; +} _GetCatalogResponse__isset; + +class GetCatalogResponse : public virtual ::apache::thrift::TBase { + public: + + GetCatalogResponse(const GetCatalogResponse&); + GetCatalogResponse& operator=(const GetCatalogResponse&); + GetCatalogResponse() noexcept; + + virtual ~GetCatalogResponse() noexcept; + Catalog catalog; + + _GetCatalogResponse__isset __isset; + + void __set_catalog(const Catalog& val); + + bool operator == (const GetCatalogResponse & rhs) const; + bool operator != (const GetCatalogResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetCatalogResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetCatalogResponse &a, GetCatalogResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetCatalogResponse& obj); + +typedef struct _GetCatalogsResponse__isset { + _GetCatalogsResponse__isset() : names(false) {} + bool names :1; +} _GetCatalogsResponse__isset; + +class GetCatalogsResponse : public virtual ::apache::thrift::TBase { + public: + + GetCatalogsResponse(const GetCatalogsResponse&); + GetCatalogsResponse& operator=(const GetCatalogsResponse&); + GetCatalogsResponse() noexcept; + + virtual ~GetCatalogsResponse() noexcept; + std::vector names; + + _GetCatalogsResponse__isset __isset; + + void __set_names(const std::vector & val); + + bool operator == (const GetCatalogsResponse & rhs) const; + bool operator != (const GetCatalogsResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetCatalogsResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetCatalogsResponse &a, GetCatalogsResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetCatalogsResponse& obj); + +typedef struct _DropCatalogRequest__isset { + _DropCatalogRequest__isset() : name(false) {} + bool name :1; +} _DropCatalogRequest__isset; + +class DropCatalogRequest : public virtual ::apache::thrift::TBase { + public: + + DropCatalogRequest(const DropCatalogRequest&); + DropCatalogRequest& operator=(const DropCatalogRequest&); + DropCatalogRequest() noexcept; + + virtual ~DropCatalogRequest() noexcept; + std::string name; + + _DropCatalogRequest__isset __isset; + + void __set_name(const std::string& val); + + bool operator == (const DropCatalogRequest & rhs) const; + bool operator != (const DropCatalogRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const DropCatalogRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(DropCatalogRequest &a, DropCatalogRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const DropCatalogRequest& obj); + +typedef struct _Database__isset { + _Database__isset() : name(false), description(false), locationUri(false), parameters(false), privileges(false), ownerName(false), ownerType(false), catalogName(false), createTime(false), managedLocationUri(false), type(false), connector_name(false), remote_dbname(false) {} + bool name :1; + bool description :1; + bool locationUri :1; + bool parameters :1; + bool privileges :1; + bool ownerName :1; + bool ownerType :1; + bool catalogName :1; + bool createTime :1; + bool managedLocationUri :1; + bool type :1; + bool connector_name :1; + bool remote_dbname :1; +} _Database__isset; + +class Database : public virtual ::apache::thrift::TBase { + public: + + Database(const Database&); + Database& operator=(const Database&); + Database() noexcept; + + virtual ~Database() noexcept; + std::string name; + std::string description; + std::string locationUri; + std::map parameters; + PrincipalPrivilegeSet privileges; + std::string ownerName; + /** + * + * @see PrincipalType + */ + PrincipalType::type ownerType; + std::string catalogName; + int32_t createTime; + std::string managedLocationUri; + /** + * + * @see DatabaseType + */ + DatabaseType::type type; + std::string connector_name; + std::string remote_dbname; + + _Database__isset __isset; + + void __set_name(const std::string& val); + + void __set_description(const std::string& val); + + void __set_locationUri(const std::string& val); + + void __set_parameters(const std::map & val); + + void __set_privileges(const PrincipalPrivilegeSet& val); + + void __set_ownerName(const std::string& val); + + void __set_ownerType(const PrincipalType::type val); + + void __set_catalogName(const std::string& val); + + void __set_createTime(const int32_t val); + + void __set_managedLocationUri(const std::string& val); + + void __set_type(const DatabaseType::type val); + + void __set_connector_name(const std::string& val); + + void __set_remote_dbname(const std::string& val); + + bool operator == (const Database & rhs) const; + bool operator != (const Database &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Database & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Database &a, Database &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const Database& obj); + +typedef struct _SerDeInfo__isset { + _SerDeInfo__isset() : name(false), serializationLib(false), parameters(false), description(false), serializerClass(false), deserializerClass(false), serdeType(false) {} + bool name :1; + bool serializationLib :1; + bool parameters :1; + bool description :1; + bool serializerClass :1; + bool deserializerClass :1; + bool serdeType :1; +} _SerDeInfo__isset; + +class SerDeInfo : public virtual ::apache::thrift::TBase { + public: + + SerDeInfo(const SerDeInfo&); + SerDeInfo& operator=(const SerDeInfo&); + SerDeInfo() noexcept; + + virtual ~SerDeInfo() noexcept; + std::string name; + std::string serializationLib; + std::map parameters; + std::string description; + std::string serializerClass; + std::string deserializerClass; + /** + * + * @see SerdeType + */ + SerdeType::type serdeType; + + _SerDeInfo__isset __isset; + + void __set_name(const std::string& val); + + void __set_serializationLib(const std::string& val); + + void __set_parameters(const std::map & val); + + void __set_description(const std::string& val); + + void __set_serializerClass(const std::string& val); + + void __set_deserializerClass(const std::string& val); + + void __set_serdeType(const SerdeType::type val); + + bool operator == (const SerDeInfo & rhs) const; + bool operator != (const SerDeInfo &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SerDeInfo & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(SerDeInfo &a, SerDeInfo &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const SerDeInfo& obj); + +typedef struct _Order__isset { + _Order__isset() : col(false), order(false) {} + bool col :1; + bool order :1; +} _Order__isset; + +class Order : public virtual ::apache::thrift::TBase { + public: + + Order(const Order&); + Order& operator=(const Order&); + Order() noexcept; + + virtual ~Order() noexcept; + std::string col; + int32_t order; + + _Order__isset __isset; + + void __set_col(const std::string& val); + + void __set_order(const int32_t val); + + bool operator == (const Order & rhs) const; + bool operator != (const Order &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Order & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Order &a, Order &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const Order& obj); + +typedef struct _SkewedInfo__isset { + _SkewedInfo__isset() : skewedColNames(false), skewedColValues(false), skewedColValueLocationMaps(false) {} + bool skewedColNames :1; + bool skewedColValues :1; + bool skewedColValueLocationMaps :1; +} _SkewedInfo__isset; + +class SkewedInfo : public virtual ::apache::thrift::TBase { + public: + + SkewedInfo(const SkewedInfo&); + SkewedInfo& operator=(const SkewedInfo&); + SkewedInfo() noexcept; + + virtual ~SkewedInfo() noexcept; + std::vector skewedColNames; + std::vector > skewedColValues; + std::map , std::string> skewedColValueLocationMaps; + + _SkewedInfo__isset __isset; + + void __set_skewedColNames(const std::vector & val); + + void __set_skewedColValues(const std::vector > & val); + + void __set_skewedColValueLocationMaps(const std::map , std::string> & val); + + bool operator == (const SkewedInfo & rhs) const; + bool operator != (const SkewedInfo &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SkewedInfo & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(SkewedInfo &a, SkewedInfo &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const SkewedInfo& obj); + +typedef struct _StorageDescriptor__isset { + _StorageDescriptor__isset() : cols(false), location(false), inputFormat(false), outputFormat(false), compressed(false), numBuckets(false), serdeInfo(false), bucketCols(false), sortCols(false), parameters(false), skewedInfo(false), storedAsSubDirectories(false) {} + bool cols :1; + bool location :1; + bool inputFormat :1; + bool outputFormat :1; + bool compressed :1; + bool numBuckets :1; + bool serdeInfo :1; + bool bucketCols :1; + bool sortCols :1; + bool parameters :1; + bool skewedInfo :1; + bool storedAsSubDirectories :1; +} _StorageDescriptor__isset; + +class StorageDescriptor : public virtual ::apache::thrift::TBase { + public: + + StorageDescriptor(const StorageDescriptor&); + StorageDescriptor& operator=(const StorageDescriptor&); + StorageDescriptor() noexcept; + + virtual ~StorageDescriptor() noexcept; + std::vector cols; + std::string location; + std::string inputFormat; + std::string outputFormat; + bool compressed; + int32_t numBuckets; + SerDeInfo serdeInfo; + std::vector bucketCols; + std::vector sortCols; + std::map parameters; + SkewedInfo skewedInfo; + bool storedAsSubDirectories; + + _StorageDescriptor__isset __isset; + + void __set_cols(const std::vector & val); + + void __set_location(const std::string& val); + + void __set_inputFormat(const std::string& val); + + void __set_outputFormat(const std::string& val); + + void __set_compressed(const bool val); + + void __set_numBuckets(const int32_t val); + + void __set_serdeInfo(const SerDeInfo& val); + + void __set_bucketCols(const std::vector & val); + + void __set_sortCols(const std::vector & val); + + void __set_parameters(const std::map & val); + + void __set_skewedInfo(const SkewedInfo& val); + + void __set_storedAsSubDirectories(const bool val); + + bool operator == (const StorageDescriptor & rhs) const; + bool operator != (const StorageDescriptor &rhs) const { + return !(*this == rhs); + } + + bool operator < (const StorageDescriptor & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(StorageDescriptor &a, StorageDescriptor &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const StorageDescriptor& obj); + +typedef struct _CreationMetadata__isset { + _CreationMetadata__isset() : validTxnList(false), materializationTime(false), sourceTables(false) {} + bool validTxnList :1; + bool materializationTime :1; + bool sourceTables :1; +} _CreationMetadata__isset; + +class CreationMetadata : public virtual ::apache::thrift::TBase { + public: + + CreationMetadata(const CreationMetadata&); + CreationMetadata& operator=(const CreationMetadata&); + CreationMetadata() noexcept; + + virtual ~CreationMetadata() noexcept; + std::string catName; + std::string dbName; + std::string tblName; + std::set tablesUsed; + std::string validTxnList; + int64_t materializationTime; + std::vector sourceTables; + + _CreationMetadata__isset __isset; + + void __set_catName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_tblName(const std::string& val); + + void __set_tablesUsed(const std::set & val); + + void __set_validTxnList(const std::string& val); + + void __set_materializationTime(const int64_t val); + + void __set_sourceTables(const std::vector & val); + + bool operator == (const CreationMetadata & rhs) const; + bool operator != (const CreationMetadata &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CreationMetadata & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(CreationMetadata &a, CreationMetadata &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const CreationMetadata& obj); + +typedef struct _BooleanColumnStatsData__isset { + _BooleanColumnStatsData__isset() : bitVectors(false) {} + bool bitVectors :1; +} _BooleanColumnStatsData__isset; + +class BooleanColumnStatsData : public virtual ::apache::thrift::TBase { + public: + + BooleanColumnStatsData(const BooleanColumnStatsData&); + BooleanColumnStatsData& operator=(const BooleanColumnStatsData&); + BooleanColumnStatsData() noexcept; + + virtual ~BooleanColumnStatsData() noexcept; + int64_t numTrues; + int64_t numFalses; + int64_t numNulls; + std::string bitVectors; + + _BooleanColumnStatsData__isset __isset; + + void __set_numTrues(const int64_t val); + + void __set_numFalses(const int64_t val); + + void __set_numNulls(const int64_t val); + + void __set_bitVectors(const std::string& val); + + bool operator == (const BooleanColumnStatsData & rhs) const; + bool operator != (const BooleanColumnStatsData &rhs) const { + return !(*this == rhs); + } + + bool operator < (const BooleanColumnStatsData & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(BooleanColumnStatsData &a, BooleanColumnStatsData &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const BooleanColumnStatsData& obj); + +typedef struct _DoubleColumnStatsData__isset { + _DoubleColumnStatsData__isset() : lowValue(false), highValue(false), bitVectors(false), histogram(false) {} + bool lowValue :1; + bool highValue :1; + bool bitVectors :1; + bool histogram :1; +} _DoubleColumnStatsData__isset; + +class DoubleColumnStatsData : public virtual ::apache::thrift::TBase { + public: + + DoubleColumnStatsData(const DoubleColumnStatsData&); + DoubleColumnStatsData& operator=(const DoubleColumnStatsData&); + DoubleColumnStatsData() noexcept; + + virtual ~DoubleColumnStatsData() noexcept; + double lowValue; + double highValue; + int64_t numNulls; + int64_t numDVs; + std::string bitVectors; + std::string histogram; + + _DoubleColumnStatsData__isset __isset; + + void __set_lowValue(const double val); + + void __set_highValue(const double val); + + void __set_numNulls(const int64_t val); + + void __set_numDVs(const int64_t val); + + void __set_bitVectors(const std::string& val); + + void __set_histogram(const std::string& val); + + bool operator == (const DoubleColumnStatsData & rhs) const; + bool operator != (const DoubleColumnStatsData &rhs) const { + return !(*this == rhs); + } + + bool operator < (const DoubleColumnStatsData & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(DoubleColumnStatsData &a, DoubleColumnStatsData &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const DoubleColumnStatsData& obj); + +typedef struct _LongColumnStatsData__isset { + _LongColumnStatsData__isset() : lowValue(false), highValue(false), bitVectors(false), histogram(false) {} + bool lowValue :1; + bool highValue :1; + bool bitVectors :1; + bool histogram :1; +} _LongColumnStatsData__isset; + +class LongColumnStatsData : public virtual ::apache::thrift::TBase { + public: + + LongColumnStatsData(const LongColumnStatsData&); + LongColumnStatsData& operator=(const LongColumnStatsData&); + LongColumnStatsData() noexcept; + + virtual ~LongColumnStatsData() noexcept; + int64_t lowValue; + int64_t highValue; + int64_t numNulls; + int64_t numDVs; + std::string bitVectors; + std::string histogram; + + _LongColumnStatsData__isset __isset; + + void __set_lowValue(const int64_t val); + + void __set_highValue(const int64_t val); + + void __set_numNulls(const int64_t val); + + void __set_numDVs(const int64_t val); + + void __set_bitVectors(const std::string& val); + + void __set_histogram(const std::string& val); + + bool operator == (const LongColumnStatsData & rhs) const; + bool operator != (const LongColumnStatsData &rhs) const { + return !(*this == rhs); + } + + bool operator < (const LongColumnStatsData & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(LongColumnStatsData &a, LongColumnStatsData &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const LongColumnStatsData& obj); + +typedef struct _StringColumnStatsData__isset { + _StringColumnStatsData__isset() : bitVectors(false) {} + bool bitVectors :1; +} _StringColumnStatsData__isset; + +class StringColumnStatsData : public virtual ::apache::thrift::TBase { + public: + + StringColumnStatsData(const StringColumnStatsData&); + StringColumnStatsData& operator=(const StringColumnStatsData&); + StringColumnStatsData() noexcept; + + virtual ~StringColumnStatsData() noexcept; + int64_t maxColLen; + double avgColLen; + int64_t numNulls; + int64_t numDVs; + std::string bitVectors; + + _StringColumnStatsData__isset __isset; + + void __set_maxColLen(const int64_t val); + + void __set_avgColLen(const double val); + + void __set_numNulls(const int64_t val); + + void __set_numDVs(const int64_t val); + + void __set_bitVectors(const std::string& val); + + bool operator == (const StringColumnStatsData & rhs) const; + bool operator != (const StringColumnStatsData &rhs) const { + return !(*this == rhs); + } + + bool operator < (const StringColumnStatsData & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(StringColumnStatsData &a, StringColumnStatsData &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const StringColumnStatsData& obj); + +typedef struct _BinaryColumnStatsData__isset { + _BinaryColumnStatsData__isset() : bitVectors(false) {} + bool bitVectors :1; +} _BinaryColumnStatsData__isset; + +class BinaryColumnStatsData : public virtual ::apache::thrift::TBase { + public: + + BinaryColumnStatsData(const BinaryColumnStatsData&); + BinaryColumnStatsData& operator=(const BinaryColumnStatsData&); + BinaryColumnStatsData() noexcept; + + virtual ~BinaryColumnStatsData() noexcept; + int64_t maxColLen; + double avgColLen; + int64_t numNulls; + std::string bitVectors; + + _BinaryColumnStatsData__isset __isset; + + void __set_maxColLen(const int64_t val); + + void __set_avgColLen(const double val); + + void __set_numNulls(const int64_t val); + + void __set_bitVectors(const std::string& val); + + bool operator == (const BinaryColumnStatsData & rhs) const; + bool operator != (const BinaryColumnStatsData &rhs) const { + return !(*this == rhs); + } + + bool operator < (const BinaryColumnStatsData & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(BinaryColumnStatsData &a, BinaryColumnStatsData &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const BinaryColumnStatsData& obj); + + +class Decimal : public virtual ::apache::thrift::TBase { + public: + + Decimal(const Decimal&); + Decimal& operator=(const Decimal&); + Decimal() noexcept; + + virtual ~Decimal() noexcept; + int16_t scale; + std::string unscaled; + + void __set_scale(const int16_t val); + + void __set_unscaled(const std::string& val); + + bool operator == (const Decimal & rhs) const; + bool operator != (const Decimal &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Decimal & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Decimal &a, Decimal &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const Decimal& obj); + +typedef struct _DecimalColumnStatsData__isset { + _DecimalColumnStatsData__isset() : lowValue(false), highValue(false), bitVectors(false), histogram(false) {} + bool lowValue :1; + bool highValue :1; + bool bitVectors :1; + bool histogram :1; +} _DecimalColumnStatsData__isset; + +class DecimalColumnStatsData : public virtual ::apache::thrift::TBase { + public: + + DecimalColumnStatsData(const DecimalColumnStatsData&); + DecimalColumnStatsData& operator=(const DecimalColumnStatsData&); + DecimalColumnStatsData() noexcept; + + virtual ~DecimalColumnStatsData() noexcept; + Decimal lowValue; + Decimal highValue; + int64_t numNulls; + int64_t numDVs; + std::string bitVectors; + std::string histogram; + + _DecimalColumnStatsData__isset __isset; + + void __set_lowValue(const Decimal& val); + + void __set_highValue(const Decimal& val); + + void __set_numNulls(const int64_t val); + + void __set_numDVs(const int64_t val); + + void __set_bitVectors(const std::string& val); + + void __set_histogram(const std::string& val); + + bool operator == (const DecimalColumnStatsData & rhs) const; + bool operator != (const DecimalColumnStatsData &rhs) const { + return !(*this == rhs); + } + + bool operator < (const DecimalColumnStatsData & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(DecimalColumnStatsData &a, DecimalColumnStatsData &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const DecimalColumnStatsData& obj); + + +class Date : public virtual ::apache::thrift::TBase { + public: + + Date(const Date&) noexcept; + Date& operator=(const Date&) noexcept; + Date() noexcept; + + virtual ~Date() noexcept; + int64_t daysSinceEpoch; + + void __set_daysSinceEpoch(const int64_t val); + + bool operator == (const Date & rhs) const; + bool operator != (const Date &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Date & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Date &a, Date &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const Date& obj); + +typedef struct _DateColumnStatsData__isset { + _DateColumnStatsData__isset() : lowValue(false), highValue(false), bitVectors(false), histogram(false) {} + bool lowValue :1; + bool highValue :1; + bool bitVectors :1; + bool histogram :1; +} _DateColumnStatsData__isset; + +class DateColumnStatsData : public virtual ::apache::thrift::TBase { + public: + + DateColumnStatsData(const DateColumnStatsData&); + DateColumnStatsData& operator=(const DateColumnStatsData&); + DateColumnStatsData() noexcept; + + virtual ~DateColumnStatsData() noexcept; + Date lowValue; + Date highValue; + int64_t numNulls; + int64_t numDVs; + std::string bitVectors; + std::string histogram; + + _DateColumnStatsData__isset __isset; + + void __set_lowValue(const Date& val); + + void __set_highValue(const Date& val); + + void __set_numNulls(const int64_t val); + + void __set_numDVs(const int64_t val); + + void __set_bitVectors(const std::string& val); + + void __set_histogram(const std::string& val); + + bool operator == (const DateColumnStatsData & rhs) const; + bool operator != (const DateColumnStatsData &rhs) const { + return !(*this == rhs); + } + + bool operator < (const DateColumnStatsData & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(DateColumnStatsData &a, DateColumnStatsData &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const DateColumnStatsData& obj); + + +class Timestamp : public virtual ::apache::thrift::TBase { + public: + + Timestamp(const Timestamp&) noexcept; + Timestamp& operator=(const Timestamp&) noexcept; + Timestamp() noexcept; + + virtual ~Timestamp() noexcept; + int64_t secondsSinceEpoch; + + void __set_secondsSinceEpoch(const int64_t val); + + bool operator == (const Timestamp & rhs) const; + bool operator != (const Timestamp &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Timestamp & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Timestamp &a, Timestamp &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const Timestamp& obj); + +typedef struct _TimestampColumnStatsData__isset { + _TimestampColumnStatsData__isset() : lowValue(false), highValue(false), bitVectors(false), histogram(false) {} + bool lowValue :1; + bool highValue :1; + bool bitVectors :1; + bool histogram :1; +} _TimestampColumnStatsData__isset; + +class TimestampColumnStatsData : public virtual ::apache::thrift::TBase { + public: + + TimestampColumnStatsData(const TimestampColumnStatsData&); + TimestampColumnStatsData& operator=(const TimestampColumnStatsData&); + TimestampColumnStatsData() noexcept; + + virtual ~TimestampColumnStatsData() noexcept; + Timestamp lowValue; + Timestamp highValue; + int64_t numNulls; + int64_t numDVs; + std::string bitVectors; + std::string histogram; + + _TimestampColumnStatsData__isset __isset; + + void __set_lowValue(const Timestamp& val); + + void __set_highValue(const Timestamp& val); + + void __set_numNulls(const int64_t val); + + void __set_numDVs(const int64_t val); + + void __set_bitVectors(const std::string& val); + + void __set_histogram(const std::string& val); + + bool operator == (const TimestampColumnStatsData & rhs) const; + bool operator != (const TimestampColumnStatsData &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TimestampColumnStatsData & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TimestampColumnStatsData &a, TimestampColumnStatsData &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const TimestampColumnStatsData& obj); + +typedef struct _ColumnStatisticsData__isset { + _ColumnStatisticsData__isset() : booleanStats(false), longStats(false), doubleStats(false), stringStats(false), binaryStats(false), decimalStats(false), dateStats(false), timestampStats(false) {} + bool booleanStats :1; + bool longStats :1; + bool doubleStats :1; + bool stringStats :1; + bool binaryStats :1; + bool decimalStats :1; + bool dateStats :1; + bool timestampStats :1; +} _ColumnStatisticsData__isset; + +class ColumnStatisticsData : public virtual ::apache::thrift::TBase { + public: + + ColumnStatisticsData(const ColumnStatisticsData&); + ColumnStatisticsData& operator=(const ColumnStatisticsData&); + ColumnStatisticsData() noexcept; + + virtual ~ColumnStatisticsData() noexcept; + BooleanColumnStatsData booleanStats; + LongColumnStatsData longStats; + DoubleColumnStatsData doubleStats; + StringColumnStatsData stringStats; + BinaryColumnStatsData binaryStats; + DecimalColumnStatsData decimalStats; + DateColumnStatsData dateStats; + TimestampColumnStatsData timestampStats; + + _ColumnStatisticsData__isset __isset; + + void __set_booleanStats(const BooleanColumnStatsData& val); + + void __set_longStats(const LongColumnStatsData& val); + + void __set_doubleStats(const DoubleColumnStatsData& val); + + void __set_stringStats(const StringColumnStatsData& val); + + void __set_binaryStats(const BinaryColumnStatsData& val); + + void __set_decimalStats(const DecimalColumnStatsData& val); + + void __set_dateStats(const DateColumnStatsData& val); + + void __set_timestampStats(const TimestampColumnStatsData& val); + + bool operator == (const ColumnStatisticsData & rhs) const; + bool operator != (const ColumnStatisticsData &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ColumnStatisticsData & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ColumnStatisticsData &a, ColumnStatisticsData &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ColumnStatisticsData& obj); + + +class ColumnStatisticsObj : public virtual ::apache::thrift::TBase { + public: + + ColumnStatisticsObj(const ColumnStatisticsObj&); + ColumnStatisticsObj& operator=(const ColumnStatisticsObj&); + ColumnStatisticsObj() noexcept; + + virtual ~ColumnStatisticsObj() noexcept; + std::string colName; + std::string colType; + ColumnStatisticsData statsData; + + void __set_colName(const std::string& val); + + void __set_colType(const std::string& val); + + void __set_statsData(const ColumnStatisticsData& val); + + bool operator == (const ColumnStatisticsObj & rhs) const; + bool operator != (const ColumnStatisticsObj &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ColumnStatisticsObj & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ColumnStatisticsObj &a, ColumnStatisticsObj &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ColumnStatisticsObj& obj); + +typedef struct _ColumnStatisticsDesc__isset { + _ColumnStatisticsDesc__isset() : partName(false), lastAnalyzed(false), catName(false) {} + bool partName :1; + bool lastAnalyzed :1; + bool catName :1; +} _ColumnStatisticsDesc__isset; + +class ColumnStatisticsDesc : public virtual ::apache::thrift::TBase { + public: + + ColumnStatisticsDesc(const ColumnStatisticsDesc&); + ColumnStatisticsDesc& operator=(const ColumnStatisticsDesc&); + ColumnStatisticsDesc() noexcept; + + virtual ~ColumnStatisticsDesc() noexcept; + bool isTblLevel; + std::string dbName; + std::string tableName; + std::string partName; + int64_t lastAnalyzed; + std::string catName; + + _ColumnStatisticsDesc__isset __isset; + + void __set_isTblLevel(const bool val); + + void __set_dbName(const std::string& val); + + void __set_tableName(const std::string& val); + + void __set_partName(const std::string& val); + + void __set_lastAnalyzed(const int64_t val); + + void __set_catName(const std::string& val); + + bool operator == (const ColumnStatisticsDesc & rhs) const; + bool operator != (const ColumnStatisticsDesc &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ColumnStatisticsDesc & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ColumnStatisticsDesc &a, ColumnStatisticsDesc &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ColumnStatisticsDesc& obj); + +typedef struct _ColumnStatistics__isset { + _ColumnStatistics__isset() : isStatsCompliant(false), engine(true) {} + bool isStatsCompliant :1; + bool engine :1; +} _ColumnStatistics__isset; + +class ColumnStatistics : public virtual ::apache::thrift::TBase { + public: + + ColumnStatistics(const ColumnStatistics&); + ColumnStatistics& operator=(const ColumnStatistics&); + ColumnStatistics(); + + virtual ~ColumnStatistics() noexcept; + ColumnStatisticsDesc statsDesc; + std::vector statsObj; + bool isStatsCompliant; + std::string engine; + + _ColumnStatistics__isset __isset; + + void __set_statsDesc(const ColumnStatisticsDesc& val); + + void __set_statsObj(const std::vector & val); + + void __set_isStatsCompliant(const bool val); + + void __set_engine(const std::string& val); + + bool operator == (const ColumnStatistics & rhs) const; + bool operator != (const ColumnStatistics &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ColumnStatistics & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ColumnStatistics &a, ColumnStatistics &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ColumnStatistics& obj); + +typedef struct _FileMetadata__isset { + _FileMetadata__isset() : type(true), version(true), data(false) {} + bool type :1; + bool version :1; + bool data :1; +} _FileMetadata__isset; + +class FileMetadata : public virtual ::apache::thrift::TBase { + public: + + FileMetadata(const FileMetadata&); + FileMetadata& operator=(const FileMetadata&); + FileMetadata() noexcept; + + virtual ~FileMetadata() noexcept; + int8_t type; + int8_t version; + std::vector data; + + _FileMetadata__isset __isset; + + void __set_type(const int8_t val); + + void __set_version(const int8_t val); + + void __set_data(const std::vector & val); + + bool operator == (const FileMetadata & rhs) const; + bool operator != (const FileMetadata &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FileMetadata & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(FileMetadata &a, FileMetadata &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const FileMetadata& obj); + + +class ObjectDictionary : public virtual ::apache::thrift::TBase { + public: + + ObjectDictionary(const ObjectDictionary&); + ObjectDictionary& operator=(const ObjectDictionary&); + ObjectDictionary() noexcept; + + virtual ~ObjectDictionary() noexcept; + std::map > values; + + void __set_values(const std::map > & val); + + bool operator == (const ObjectDictionary & rhs) const; + bool operator != (const ObjectDictionary &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ObjectDictionary & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ObjectDictionary &a, ObjectDictionary &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ObjectDictionary& obj); + +typedef struct _Table__isset { + _Table__isset() : tableName(false), dbName(false), owner(false), createTime(false), lastAccessTime(false), retention(false), sd(false), partitionKeys(false), parameters(false), viewOriginalText(false), viewExpandedText(false), tableType(false), privileges(false), temporary(true), rewriteEnabled(false), creationMetadata(false), catName(false), ownerType(true), writeId(true), isStatsCompliant(false), colStats(false), accessType(false), requiredReadCapabilities(false), requiredWriteCapabilities(false), id(false), fileMetadata(false), dictionary(false), txnId(false) {} + bool tableName :1; + bool dbName :1; + bool owner :1; + bool createTime :1; + bool lastAccessTime :1; + bool retention :1; + bool sd :1; + bool partitionKeys :1; + bool parameters :1; + bool viewOriginalText :1; + bool viewExpandedText :1; + bool tableType :1; + bool privileges :1; + bool temporary :1; + bool rewriteEnabled :1; + bool creationMetadata :1; + bool catName :1; + bool ownerType :1; + bool writeId :1; + bool isStatsCompliant :1; + bool colStats :1; + bool accessType :1; + bool requiredReadCapabilities :1; + bool requiredWriteCapabilities :1; + bool id :1; + bool fileMetadata :1; + bool dictionary :1; + bool txnId :1; +} _Table__isset; + +class Table : public virtual ::apache::thrift::TBase { + public: + + Table(const Table&); + Table& operator=(const Table&); + Table() noexcept; + + virtual ~Table() noexcept; + std::string tableName; + std::string dbName; + std::string owner; + int32_t createTime; + int32_t lastAccessTime; + int32_t retention; + StorageDescriptor sd; + std::vector partitionKeys; + std::map parameters; + std::string viewOriginalText; + std::string viewExpandedText; + std::string tableType; + PrincipalPrivilegeSet privileges; + bool temporary; + bool rewriteEnabled; + CreationMetadata creationMetadata; + std::string catName; + /** + * + * @see PrincipalType + */ + PrincipalType::type ownerType; + int64_t writeId; + bool isStatsCompliant; + ColumnStatistics colStats; + int8_t accessType; + std::vector requiredReadCapabilities; + std::vector requiredWriteCapabilities; + int64_t id; + FileMetadata fileMetadata; + ObjectDictionary dictionary; + int64_t txnId; + + _Table__isset __isset; + + void __set_tableName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_owner(const std::string& val); + + void __set_createTime(const int32_t val); + + void __set_lastAccessTime(const int32_t val); + + void __set_retention(const int32_t val); + + void __set_sd(const StorageDescriptor& val); + + void __set_partitionKeys(const std::vector & val); + + void __set_parameters(const std::map & val); + + void __set_viewOriginalText(const std::string& val); + + void __set_viewExpandedText(const std::string& val); + + void __set_tableType(const std::string& val); + + void __set_privileges(const PrincipalPrivilegeSet& val); + + void __set_temporary(const bool val); + + void __set_rewriteEnabled(const bool val); + + void __set_creationMetadata(const CreationMetadata& val); + + void __set_catName(const std::string& val); + + void __set_ownerType(const PrincipalType::type val); + + void __set_writeId(const int64_t val); + + void __set_isStatsCompliant(const bool val); + + void __set_colStats(const ColumnStatistics& val); + + void __set_accessType(const int8_t val); + + void __set_requiredReadCapabilities(const std::vector & val); + + void __set_requiredWriteCapabilities(const std::vector & val); + + void __set_id(const int64_t val); + + void __set_fileMetadata(const FileMetadata& val); + + void __set_dictionary(const ObjectDictionary& val); + + void __set_txnId(const int64_t val); + + bool operator == (const Table & rhs) const; + bool operator != (const Table &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Table & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Table &a, Table &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const Table& obj); + + +class SourceTable : public virtual ::apache::thrift::TBase { + public: + + SourceTable(const SourceTable&); + SourceTable& operator=(const SourceTable&); + SourceTable() noexcept; + + virtual ~SourceTable() noexcept; + Table table; + int64_t insertedCount; + int64_t updatedCount; + int64_t deletedCount; + + void __set_table(const Table& val); + + void __set_insertedCount(const int64_t val); + + void __set_updatedCount(const int64_t val); + + void __set_deletedCount(const int64_t val); + + bool operator == (const SourceTable & rhs) const; + bool operator != (const SourceTable &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SourceTable & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(SourceTable &a, SourceTable &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const SourceTable& obj); + +typedef struct _Partition__isset { + _Partition__isset() : values(false), dbName(false), tableName(false), createTime(false), lastAccessTime(false), sd(false), parameters(false), privileges(false), catName(false), writeId(true), isStatsCompliant(false), colStats(false), fileMetadata(false) {} + bool values :1; + bool dbName :1; + bool tableName :1; + bool createTime :1; + bool lastAccessTime :1; + bool sd :1; + bool parameters :1; + bool privileges :1; + bool catName :1; + bool writeId :1; + bool isStatsCompliant :1; + bool colStats :1; + bool fileMetadata :1; +} _Partition__isset; + +class Partition : public virtual ::apache::thrift::TBase { + public: + + Partition(const Partition&); + Partition& operator=(const Partition&); + Partition() noexcept; + + virtual ~Partition() noexcept; + std::vector values; + std::string dbName; + std::string tableName; + int32_t createTime; + int32_t lastAccessTime; + StorageDescriptor sd; + std::map parameters; + PrincipalPrivilegeSet privileges; + std::string catName; + int64_t writeId; + bool isStatsCompliant; + ColumnStatistics colStats; + FileMetadata fileMetadata; + + _Partition__isset __isset; + + void __set_values(const std::vector & val); + + void __set_dbName(const std::string& val); + + void __set_tableName(const std::string& val); + + void __set_createTime(const int32_t val); + + void __set_lastAccessTime(const int32_t val); + + void __set_sd(const StorageDescriptor& val); + + void __set_parameters(const std::map & val); + + void __set_privileges(const PrincipalPrivilegeSet& val); + + void __set_catName(const std::string& val); + + void __set_writeId(const int64_t val); + + void __set_isStatsCompliant(const bool val); + + void __set_colStats(const ColumnStatistics& val); + + void __set_fileMetadata(const FileMetadata& val); + + bool operator == (const Partition & rhs) const; + bool operator != (const Partition &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Partition & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Partition &a, Partition &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const Partition& obj); + +typedef struct _PartitionWithoutSD__isset { + _PartitionWithoutSD__isset() : values(false), createTime(false), lastAccessTime(false), relativePath(false), parameters(false), privileges(false) {} + bool values :1; + bool createTime :1; + bool lastAccessTime :1; + bool relativePath :1; + bool parameters :1; + bool privileges :1; +} _PartitionWithoutSD__isset; + +class PartitionWithoutSD : public virtual ::apache::thrift::TBase { + public: + + PartitionWithoutSD(const PartitionWithoutSD&); + PartitionWithoutSD& operator=(const PartitionWithoutSD&); + PartitionWithoutSD() noexcept; + + virtual ~PartitionWithoutSD() noexcept; + std::vector values; + int32_t createTime; + int32_t lastAccessTime; + std::string relativePath; + std::map parameters; + PrincipalPrivilegeSet privileges; + + _PartitionWithoutSD__isset __isset; + + void __set_values(const std::vector & val); + + void __set_createTime(const int32_t val); + + void __set_lastAccessTime(const int32_t val); + + void __set_relativePath(const std::string& val); + + void __set_parameters(const std::map & val); + + void __set_privileges(const PrincipalPrivilegeSet& val); + + bool operator == (const PartitionWithoutSD & rhs) const; + bool operator != (const PartitionWithoutSD &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PartitionWithoutSD & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PartitionWithoutSD &a, PartitionWithoutSD &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PartitionWithoutSD& obj); + +typedef struct _PartitionSpecWithSharedSD__isset { + _PartitionSpecWithSharedSD__isset() : partitions(false), sd(false) {} + bool partitions :1; + bool sd :1; +} _PartitionSpecWithSharedSD__isset; + +class PartitionSpecWithSharedSD : public virtual ::apache::thrift::TBase { + public: + + PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD&); + PartitionSpecWithSharedSD& operator=(const PartitionSpecWithSharedSD&); + PartitionSpecWithSharedSD() noexcept; + + virtual ~PartitionSpecWithSharedSD() noexcept; + std::vector partitions; + StorageDescriptor sd; + + _PartitionSpecWithSharedSD__isset __isset; + + void __set_partitions(const std::vector & val); + + void __set_sd(const StorageDescriptor& val); + + bool operator == (const PartitionSpecWithSharedSD & rhs) const; + bool operator != (const PartitionSpecWithSharedSD &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PartitionSpecWithSharedSD & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PartitionSpecWithSharedSD &a, PartitionSpecWithSharedSD &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PartitionSpecWithSharedSD& obj); + +typedef struct _PartitionListComposingSpec__isset { + _PartitionListComposingSpec__isset() : partitions(false) {} + bool partitions :1; +} _PartitionListComposingSpec__isset; + +class PartitionListComposingSpec : public virtual ::apache::thrift::TBase { + public: + + PartitionListComposingSpec(const PartitionListComposingSpec&); + PartitionListComposingSpec& operator=(const PartitionListComposingSpec&); + PartitionListComposingSpec() noexcept; + + virtual ~PartitionListComposingSpec() noexcept; + std::vector partitions; + + _PartitionListComposingSpec__isset __isset; + + void __set_partitions(const std::vector & val); + + bool operator == (const PartitionListComposingSpec & rhs) const; + bool operator != (const PartitionListComposingSpec &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PartitionListComposingSpec & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PartitionListComposingSpec &a, PartitionListComposingSpec &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PartitionListComposingSpec& obj); + +typedef struct _PartitionSpec__isset { + _PartitionSpec__isset() : dbName(false), tableName(false), rootPath(false), sharedSDPartitionSpec(false), partitionList(false), catName(false), writeId(true), isStatsCompliant(false) {} + bool dbName :1; + bool tableName :1; + bool rootPath :1; + bool sharedSDPartitionSpec :1; + bool partitionList :1; + bool catName :1; + bool writeId :1; + bool isStatsCompliant :1; +} _PartitionSpec__isset; + +class PartitionSpec : public virtual ::apache::thrift::TBase { + public: + + PartitionSpec(const PartitionSpec&); + PartitionSpec& operator=(const PartitionSpec&); + PartitionSpec() noexcept; + + virtual ~PartitionSpec() noexcept; + std::string dbName; + std::string tableName; + std::string rootPath; + PartitionSpecWithSharedSD sharedSDPartitionSpec; + PartitionListComposingSpec partitionList; + std::string catName; + int64_t writeId; + bool isStatsCompliant; + + _PartitionSpec__isset __isset; + + void __set_dbName(const std::string& val); + + void __set_tableName(const std::string& val); + + void __set_rootPath(const std::string& val); + + void __set_sharedSDPartitionSpec(const PartitionSpecWithSharedSD& val); + + void __set_partitionList(const PartitionListComposingSpec& val); + + void __set_catName(const std::string& val); + + void __set_writeId(const int64_t val); + + void __set_isStatsCompliant(const bool val); + + bool operator == (const PartitionSpec & rhs) const; + bool operator != (const PartitionSpec &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PartitionSpec & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PartitionSpec &a, PartitionSpec &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PartitionSpec& obj); + +typedef struct _AggrStats__isset { + _AggrStats__isset() : isStatsCompliant(false) {} + bool isStatsCompliant :1; +} _AggrStats__isset; + +class AggrStats : public virtual ::apache::thrift::TBase { + public: + + AggrStats(const AggrStats&); + AggrStats& operator=(const AggrStats&); + AggrStats() noexcept; + + virtual ~AggrStats() noexcept; + std::vector colStats; + int64_t partsFound; + bool isStatsCompliant; + + _AggrStats__isset __isset; + + void __set_colStats(const std::vector & val); + + void __set_partsFound(const int64_t val); + + void __set_isStatsCompliant(const bool val); + + bool operator == (const AggrStats & rhs) const; + bool operator != (const AggrStats &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AggrStats & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AggrStats &a, AggrStats &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AggrStats& obj); + +typedef struct _SetPartitionsStatsRequest__isset { + _SetPartitionsStatsRequest__isset() : needMerge(false), writeId(true), validWriteIdList(false), engine(true) {} + bool needMerge :1; + bool writeId :1; + bool validWriteIdList :1; + bool engine :1; +} _SetPartitionsStatsRequest__isset; + +class SetPartitionsStatsRequest : public virtual ::apache::thrift::TBase { + public: + + SetPartitionsStatsRequest(const SetPartitionsStatsRequest&); + SetPartitionsStatsRequest& operator=(const SetPartitionsStatsRequest&); + SetPartitionsStatsRequest(); + + virtual ~SetPartitionsStatsRequest() noexcept; + std::vector colStats; + bool needMerge; + int64_t writeId; + std::string validWriteIdList; + std::string engine; + + _SetPartitionsStatsRequest__isset __isset; + + void __set_colStats(const std::vector & val); + + void __set_needMerge(const bool val); + + void __set_writeId(const int64_t val); + + void __set_validWriteIdList(const std::string& val); + + void __set_engine(const std::string& val); + + bool operator == (const SetPartitionsStatsRequest & rhs) const; + bool operator != (const SetPartitionsStatsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SetPartitionsStatsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(SetPartitionsStatsRequest &a, SetPartitionsStatsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const SetPartitionsStatsRequest& obj); + + +class SetPartitionsStatsResponse : public virtual ::apache::thrift::TBase { + public: + + SetPartitionsStatsResponse(const SetPartitionsStatsResponse&) noexcept; + SetPartitionsStatsResponse& operator=(const SetPartitionsStatsResponse&) noexcept; + SetPartitionsStatsResponse() noexcept; + + virtual ~SetPartitionsStatsResponse() noexcept; + bool result; + + void __set_result(const bool val); + + bool operator == (const SetPartitionsStatsResponse & rhs) const; + bool operator != (const SetPartitionsStatsResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SetPartitionsStatsResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(SetPartitionsStatsResponse &a, SetPartitionsStatsResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const SetPartitionsStatsResponse& obj); + +typedef struct _Schema__isset { + _Schema__isset() : fieldSchemas(false), properties(false) {} + bool fieldSchemas :1; + bool properties :1; +} _Schema__isset; + +class Schema : public virtual ::apache::thrift::TBase { + public: + + Schema(const Schema&); + Schema& operator=(const Schema&); + Schema() noexcept; + + virtual ~Schema() noexcept; + std::vector fieldSchemas; + std::map properties; + + _Schema__isset __isset; + + void __set_fieldSchemas(const std::vector & val); + + void __set_properties(const std::map & val); + + bool operator == (const Schema & rhs) const; + bool operator != (const Schema &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Schema & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Schema &a, Schema &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const Schema& obj); + +typedef struct _PrimaryKeysRequest__isset { + _PrimaryKeysRequest__isset() : catName(false), validWriteIdList(false), tableId(true) {} + bool catName :1; + bool validWriteIdList :1; + bool tableId :1; +} _PrimaryKeysRequest__isset; + +class PrimaryKeysRequest : public virtual ::apache::thrift::TBase { + public: + + PrimaryKeysRequest(const PrimaryKeysRequest&); + PrimaryKeysRequest& operator=(const PrimaryKeysRequest&); + PrimaryKeysRequest() noexcept; + + virtual ~PrimaryKeysRequest() noexcept; + std::string db_name; + std::string tbl_name; + std::string catName; + std::string validWriteIdList; + int64_t tableId; + + _PrimaryKeysRequest__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_catName(const std::string& val); + + void __set_validWriteIdList(const std::string& val); + + void __set_tableId(const int64_t val); + + bool operator == (const PrimaryKeysRequest & rhs) const; + bool operator != (const PrimaryKeysRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PrimaryKeysRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PrimaryKeysRequest &a, PrimaryKeysRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PrimaryKeysRequest& obj); + + +class PrimaryKeysResponse : public virtual ::apache::thrift::TBase { + public: + + PrimaryKeysResponse(const PrimaryKeysResponse&); + PrimaryKeysResponse& operator=(const PrimaryKeysResponse&); + PrimaryKeysResponse() noexcept; + + virtual ~PrimaryKeysResponse() noexcept; + std::vector primaryKeys; + + void __set_primaryKeys(const std::vector & val); + + bool operator == (const PrimaryKeysResponse & rhs) const; + bool operator != (const PrimaryKeysResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PrimaryKeysResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PrimaryKeysResponse &a, PrimaryKeysResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PrimaryKeysResponse& obj); + +typedef struct _ForeignKeysRequest__isset { + _ForeignKeysRequest__isset() : parent_db_name(false), parent_tbl_name(false), foreign_db_name(false), foreign_tbl_name(false), catName(false), validWriteIdList(false), tableId(true) {} + bool parent_db_name :1; + bool parent_tbl_name :1; + bool foreign_db_name :1; + bool foreign_tbl_name :1; + bool catName :1; + bool validWriteIdList :1; + bool tableId :1; +} _ForeignKeysRequest__isset; + +class ForeignKeysRequest : public virtual ::apache::thrift::TBase { + public: + + ForeignKeysRequest(const ForeignKeysRequest&); + ForeignKeysRequest& operator=(const ForeignKeysRequest&); + ForeignKeysRequest() noexcept; + + virtual ~ForeignKeysRequest() noexcept; + std::string parent_db_name; + std::string parent_tbl_name; + std::string foreign_db_name; + std::string foreign_tbl_name; + std::string catName; + std::string validWriteIdList; + int64_t tableId; + + _ForeignKeysRequest__isset __isset; + + void __set_parent_db_name(const std::string& val); + + void __set_parent_tbl_name(const std::string& val); + + void __set_foreign_db_name(const std::string& val); + + void __set_foreign_tbl_name(const std::string& val); + + void __set_catName(const std::string& val); + + void __set_validWriteIdList(const std::string& val); + + void __set_tableId(const int64_t val); + + bool operator == (const ForeignKeysRequest & rhs) const; + bool operator != (const ForeignKeysRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ForeignKeysRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ForeignKeysRequest &a, ForeignKeysRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ForeignKeysRequest& obj); + + +class ForeignKeysResponse : public virtual ::apache::thrift::TBase { + public: + + ForeignKeysResponse(const ForeignKeysResponse&); + ForeignKeysResponse& operator=(const ForeignKeysResponse&); + ForeignKeysResponse() noexcept; + + virtual ~ForeignKeysResponse() noexcept; + std::vector foreignKeys; + + void __set_foreignKeys(const std::vector & val); + + bool operator == (const ForeignKeysResponse & rhs) const; + bool operator != (const ForeignKeysResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ForeignKeysResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ForeignKeysResponse &a, ForeignKeysResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ForeignKeysResponse& obj); + +typedef struct _UniqueConstraintsRequest__isset { + _UniqueConstraintsRequest__isset() : validWriteIdList(false), tableId(true) {} + bool validWriteIdList :1; + bool tableId :1; +} _UniqueConstraintsRequest__isset; + +class UniqueConstraintsRequest : public virtual ::apache::thrift::TBase { + public: + + UniqueConstraintsRequest(const UniqueConstraintsRequest&); + UniqueConstraintsRequest& operator=(const UniqueConstraintsRequest&); + UniqueConstraintsRequest() noexcept; + + virtual ~UniqueConstraintsRequest() noexcept; + std::string catName; + std::string db_name; + std::string tbl_name; + std::string validWriteIdList; + int64_t tableId; + + _UniqueConstraintsRequest__isset __isset; + + void __set_catName(const std::string& val); + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_validWriteIdList(const std::string& val); + + void __set_tableId(const int64_t val); + + bool operator == (const UniqueConstraintsRequest & rhs) const; + bool operator != (const UniqueConstraintsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const UniqueConstraintsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(UniqueConstraintsRequest &a, UniqueConstraintsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const UniqueConstraintsRequest& obj); + + +class UniqueConstraintsResponse : public virtual ::apache::thrift::TBase { + public: + + UniqueConstraintsResponse(const UniqueConstraintsResponse&); + UniqueConstraintsResponse& operator=(const UniqueConstraintsResponse&); + UniqueConstraintsResponse() noexcept; + + virtual ~UniqueConstraintsResponse() noexcept; + std::vector uniqueConstraints; + + void __set_uniqueConstraints(const std::vector & val); + + bool operator == (const UniqueConstraintsResponse & rhs) const; + bool operator != (const UniqueConstraintsResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const UniqueConstraintsResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(UniqueConstraintsResponse &a, UniqueConstraintsResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const UniqueConstraintsResponse& obj); + +typedef struct _NotNullConstraintsRequest__isset { + _NotNullConstraintsRequest__isset() : validWriteIdList(false), tableId(true) {} + bool validWriteIdList :1; + bool tableId :1; +} _NotNullConstraintsRequest__isset; + +class NotNullConstraintsRequest : public virtual ::apache::thrift::TBase { + public: + + NotNullConstraintsRequest(const NotNullConstraintsRequest&); + NotNullConstraintsRequest& operator=(const NotNullConstraintsRequest&); + NotNullConstraintsRequest() noexcept; + + virtual ~NotNullConstraintsRequest() noexcept; + std::string catName; + std::string db_name; + std::string tbl_name; + std::string validWriteIdList; + int64_t tableId; + + _NotNullConstraintsRequest__isset __isset; + + void __set_catName(const std::string& val); + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_validWriteIdList(const std::string& val); + + void __set_tableId(const int64_t val); + + bool operator == (const NotNullConstraintsRequest & rhs) const; + bool operator != (const NotNullConstraintsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const NotNullConstraintsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(NotNullConstraintsRequest &a, NotNullConstraintsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const NotNullConstraintsRequest& obj); + + +class NotNullConstraintsResponse : public virtual ::apache::thrift::TBase { + public: + + NotNullConstraintsResponse(const NotNullConstraintsResponse&); + NotNullConstraintsResponse& operator=(const NotNullConstraintsResponse&); + NotNullConstraintsResponse() noexcept; + + virtual ~NotNullConstraintsResponse() noexcept; + std::vector notNullConstraints; + + void __set_notNullConstraints(const std::vector & val); + + bool operator == (const NotNullConstraintsResponse & rhs) const; + bool operator != (const NotNullConstraintsResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const NotNullConstraintsResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(NotNullConstraintsResponse &a, NotNullConstraintsResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const NotNullConstraintsResponse& obj); + +typedef struct _DefaultConstraintsRequest__isset { + _DefaultConstraintsRequest__isset() : validWriteIdList(false), tableId(true) {} + bool validWriteIdList :1; + bool tableId :1; +} _DefaultConstraintsRequest__isset; + +class DefaultConstraintsRequest : public virtual ::apache::thrift::TBase { + public: + + DefaultConstraintsRequest(const DefaultConstraintsRequest&); + DefaultConstraintsRequest& operator=(const DefaultConstraintsRequest&); + DefaultConstraintsRequest() noexcept; + + virtual ~DefaultConstraintsRequest() noexcept; + std::string catName; + std::string db_name; + std::string tbl_name; + std::string validWriteIdList; + int64_t tableId; + + _DefaultConstraintsRequest__isset __isset; + + void __set_catName(const std::string& val); + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_validWriteIdList(const std::string& val); + + void __set_tableId(const int64_t val); + + bool operator == (const DefaultConstraintsRequest & rhs) const; + bool operator != (const DefaultConstraintsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const DefaultConstraintsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(DefaultConstraintsRequest &a, DefaultConstraintsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const DefaultConstraintsRequest& obj); + + +class DefaultConstraintsResponse : public virtual ::apache::thrift::TBase { + public: + + DefaultConstraintsResponse(const DefaultConstraintsResponse&); + DefaultConstraintsResponse& operator=(const DefaultConstraintsResponse&); + DefaultConstraintsResponse() noexcept; + + virtual ~DefaultConstraintsResponse() noexcept; + std::vector defaultConstraints; + + void __set_defaultConstraints(const std::vector & val); + + bool operator == (const DefaultConstraintsResponse & rhs) const; + bool operator != (const DefaultConstraintsResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const DefaultConstraintsResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(DefaultConstraintsResponse &a, DefaultConstraintsResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const DefaultConstraintsResponse& obj); + +typedef struct _CheckConstraintsRequest__isset { + _CheckConstraintsRequest__isset() : validWriteIdList(false), tableId(true) {} + bool validWriteIdList :1; + bool tableId :1; +} _CheckConstraintsRequest__isset; + +class CheckConstraintsRequest : public virtual ::apache::thrift::TBase { + public: + + CheckConstraintsRequest(const CheckConstraintsRequest&); + CheckConstraintsRequest& operator=(const CheckConstraintsRequest&); + CheckConstraintsRequest() noexcept; + + virtual ~CheckConstraintsRequest() noexcept; + std::string catName; + std::string db_name; + std::string tbl_name; + std::string validWriteIdList; + int64_t tableId; + + _CheckConstraintsRequest__isset __isset; + + void __set_catName(const std::string& val); + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_validWriteIdList(const std::string& val); + + void __set_tableId(const int64_t val); + + bool operator == (const CheckConstraintsRequest & rhs) const; + bool operator != (const CheckConstraintsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CheckConstraintsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(CheckConstraintsRequest &a, CheckConstraintsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const CheckConstraintsRequest& obj); + + +class CheckConstraintsResponse : public virtual ::apache::thrift::TBase { + public: + + CheckConstraintsResponse(const CheckConstraintsResponse&); + CheckConstraintsResponse& operator=(const CheckConstraintsResponse&); + CheckConstraintsResponse() noexcept; + + virtual ~CheckConstraintsResponse() noexcept; + std::vector checkConstraints; + + void __set_checkConstraints(const std::vector & val); + + bool operator == (const CheckConstraintsResponse & rhs) const; + bool operator != (const CheckConstraintsResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CheckConstraintsResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(CheckConstraintsResponse &a, CheckConstraintsResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const CheckConstraintsResponse& obj); + +typedef struct _AllTableConstraintsRequest__isset { + _AllTableConstraintsRequest__isset() : validWriteIdList(false), tableId(true) {} + bool validWriteIdList :1; + bool tableId :1; +} _AllTableConstraintsRequest__isset; + +class AllTableConstraintsRequest : public virtual ::apache::thrift::TBase { + public: + + AllTableConstraintsRequest(const AllTableConstraintsRequest&); + AllTableConstraintsRequest& operator=(const AllTableConstraintsRequest&); + AllTableConstraintsRequest() noexcept; + + virtual ~AllTableConstraintsRequest() noexcept; + std::string dbName; + std::string tblName; + std::string catName; + std::string validWriteIdList; + int64_t tableId; + + _AllTableConstraintsRequest__isset __isset; + + void __set_dbName(const std::string& val); + + void __set_tblName(const std::string& val); + + void __set_catName(const std::string& val); + + void __set_validWriteIdList(const std::string& val); + + void __set_tableId(const int64_t val); + + bool operator == (const AllTableConstraintsRequest & rhs) const; + bool operator != (const AllTableConstraintsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AllTableConstraintsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AllTableConstraintsRequest &a, AllTableConstraintsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AllTableConstraintsRequest& obj); + + +class AllTableConstraintsResponse : public virtual ::apache::thrift::TBase { + public: + + AllTableConstraintsResponse(const AllTableConstraintsResponse&); + AllTableConstraintsResponse& operator=(const AllTableConstraintsResponse&); + AllTableConstraintsResponse() noexcept; + + virtual ~AllTableConstraintsResponse() noexcept; + SQLAllTableConstraints allTableConstraints; + + void __set_allTableConstraints(const SQLAllTableConstraints& val); + + bool operator == (const AllTableConstraintsResponse & rhs) const; + bool operator != (const AllTableConstraintsResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AllTableConstraintsResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AllTableConstraintsResponse &a, AllTableConstraintsResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AllTableConstraintsResponse& obj); + +typedef struct _DropConstraintRequest__isset { + _DropConstraintRequest__isset() : catName(false) {} + bool catName :1; +} _DropConstraintRequest__isset; + +class DropConstraintRequest : public virtual ::apache::thrift::TBase { + public: + + DropConstraintRequest(const DropConstraintRequest&); + DropConstraintRequest& operator=(const DropConstraintRequest&); + DropConstraintRequest() noexcept; + + virtual ~DropConstraintRequest() noexcept; + std::string dbname; + std::string tablename; + std::string constraintname; + std::string catName; + + _DropConstraintRequest__isset __isset; + + void __set_dbname(const std::string& val); + + void __set_tablename(const std::string& val); + + void __set_constraintname(const std::string& val); + + void __set_catName(const std::string& val); + + bool operator == (const DropConstraintRequest & rhs) const; + bool operator != (const DropConstraintRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const DropConstraintRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(DropConstraintRequest &a, DropConstraintRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const DropConstraintRequest& obj); + + +class AddPrimaryKeyRequest : public virtual ::apache::thrift::TBase { + public: + + AddPrimaryKeyRequest(const AddPrimaryKeyRequest&); + AddPrimaryKeyRequest& operator=(const AddPrimaryKeyRequest&); + AddPrimaryKeyRequest() noexcept; + + virtual ~AddPrimaryKeyRequest() noexcept; + std::vector primaryKeyCols; + + void __set_primaryKeyCols(const std::vector & val); + + bool operator == (const AddPrimaryKeyRequest & rhs) const; + bool operator != (const AddPrimaryKeyRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AddPrimaryKeyRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AddPrimaryKeyRequest &a, AddPrimaryKeyRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AddPrimaryKeyRequest& obj); + + +class AddForeignKeyRequest : public virtual ::apache::thrift::TBase { + public: + + AddForeignKeyRequest(const AddForeignKeyRequest&); + AddForeignKeyRequest& operator=(const AddForeignKeyRequest&); + AddForeignKeyRequest() noexcept; + + virtual ~AddForeignKeyRequest() noexcept; + std::vector foreignKeyCols; + + void __set_foreignKeyCols(const std::vector & val); + + bool operator == (const AddForeignKeyRequest & rhs) const; + bool operator != (const AddForeignKeyRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AddForeignKeyRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AddForeignKeyRequest &a, AddForeignKeyRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AddForeignKeyRequest& obj); + + +class AddUniqueConstraintRequest : public virtual ::apache::thrift::TBase { + public: + + AddUniqueConstraintRequest(const AddUniqueConstraintRequest&); + AddUniqueConstraintRequest& operator=(const AddUniqueConstraintRequest&); + AddUniqueConstraintRequest() noexcept; + + virtual ~AddUniqueConstraintRequest() noexcept; + std::vector uniqueConstraintCols; + + void __set_uniqueConstraintCols(const std::vector & val); + + bool operator == (const AddUniqueConstraintRequest & rhs) const; + bool operator != (const AddUniqueConstraintRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AddUniqueConstraintRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AddUniqueConstraintRequest &a, AddUniqueConstraintRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AddUniqueConstraintRequest& obj); + + +class AddNotNullConstraintRequest : public virtual ::apache::thrift::TBase { + public: + + AddNotNullConstraintRequest(const AddNotNullConstraintRequest&); + AddNotNullConstraintRequest& operator=(const AddNotNullConstraintRequest&); + AddNotNullConstraintRequest() noexcept; + + virtual ~AddNotNullConstraintRequest() noexcept; + std::vector notNullConstraintCols; + + void __set_notNullConstraintCols(const std::vector & val); + + bool operator == (const AddNotNullConstraintRequest & rhs) const; + bool operator != (const AddNotNullConstraintRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AddNotNullConstraintRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AddNotNullConstraintRequest &a, AddNotNullConstraintRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AddNotNullConstraintRequest& obj); + + +class AddDefaultConstraintRequest : public virtual ::apache::thrift::TBase { + public: + + AddDefaultConstraintRequest(const AddDefaultConstraintRequest&); + AddDefaultConstraintRequest& operator=(const AddDefaultConstraintRequest&); + AddDefaultConstraintRequest() noexcept; + + virtual ~AddDefaultConstraintRequest() noexcept; + std::vector defaultConstraintCols; + + void __set_defaultConstraintCols(const std::vector & val); + + bool operator == (const AddDefaultConstraintRequest & rhs) const; + bool operator != (const AddDefaultConstraintRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AddDefaultConstraintRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AddDefaultConstraintRequest &a, AddDefaultConstraintRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AddDefaultConstraintRequest& obj); + + +class AddCheckConstraintRequest : public virtual ::apache::thrift::TBase { + public: + + AddCheckConstraintRequest(const AddCheckConstraintRequest&); + AddCheckConstraintRequest& operator=(const AddCheckConstraintRequest&); + AddCheckConstraintRequest() noexcept; + + virtual ~AddCheckConstraintRequest() noexcept; + std::vector checkConstraintCols; + + void __set_checkConstraintCols(const std::vector & val); + + bool operator == (const AddCheckConstraintRequest & rhs) const; + bool operator != (const AddCheckConstraintRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AddCheckConstraintRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AddCheckConstraintRequest &a, AddCheckConstraintRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AddCheckConstraintRequest& obj); + + +class PartitionsByExprResult : public virtual ::apache::thrift::TBase { + public: + + PartitionsByExprResult(const PartitionsByExprResult&); + PartitionsByExprResult& operator=(const PartitionsByExprResult&); + PartitionsByExprResult() noexcept; + + virtual ~PartitionsByExprResult() noexcept; + std::vector partitions; + bool hasUnknownPartitions; + + void __set_partitions(const std::vector & val); + + void __set_hasUnknownPartitions(const bool val); + + bool operator == (const PartitionsByExprResult & rhs) const; + bool operator != (const PartitionsByExprResult &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PartitionsByExprResult & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PartitionsByExprResult &a, PartitionsByExprResult &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PartitionsByExprResult& obj); + + +class PartitionsSpecByExprResult : public virtual ::apache::thrift::TBase { + public: + + PartitionsSpecByExprResult(const PartitionsSpecByExprResult&); + PartitionsSpecByExprResult& operator=(const PartitionsSpecByExprResult&); + PartitionsSpecByExprResult() noexcept; + + virtual ~PartitionsSpecByExprResult() noexcept; + std::vector partitionsSpec; + bool hasUnknownPartitions; + + void __set_partitionsSpec(const std::vector & val); + + void __set_hasUnknownPartitions(const bool val); + + bool operator == (const PartitionsSpecByExprResult & rhs) const; + bool operator != (const PartitionsSpecByExprResult &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PartitionsSpecByExprResult & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PartitionsSpecByExprResult &a, PartitionsSpecByExprResult &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PartitionsSpecByExprResult& obj); + +typedef struct _PartitionsByExprRequest__isset { + _PartitionsByExprRequest__isset() : defaultPartitionName(false), maxParts(true), catName(false), order(false), validWriteIdList(false), id(true), skipColumnSchemaForPartition(false), includeParamKeyPattern(false), excludeParamKeyPattern(false) {} + bool defaultPartitionName :1; + bool maxParts :1; + bool catName :1; + bool order :1; + bool validWriteIdList :1; + bool id :1; + bool skipColumnSchemaForPartition :1; + bool includeParamKeyPattern :1; + bool excludeParamKeyPattern :1; +} _PartitionsByExprRequest__isset; + +class PartitionsByExprRequest : public virtual ::apache::thrift::TBase { + public: + + PartitionsByExprRequest(const PartitionsByExprRequest&); + PartitionsByExprRequest& operator=(const PartitionsByExprRequest&); + PartitionsByExprRequest() noexcept; + + virtual ~PartitionsByExprRequest() noexcept; + std::string dbName; + std::string tblName; + std::string expr; + std::string defaultPartitionName; + int16_t maxParts; + std::string catName; + std::string order; + std::string validWriteIdList; + int64_t id; + bool skipColumnSchemaForPartition; + std::string includeParamKeyPattern; + std::string excludeParamKeyPattern; + + _PartitionsByExprRequest__isset __isset; + + void __set_dbName(const std::string& val); + + void __set_tblName(const std::string& val); + + void __set_expr(const std::string& val); + + void __set_defaultPartitionName(const std::string& val); + + void __set_maxParts(const int16_t val); + + void __set_catName(const std::string& val); + + void __set_order(const std::string& val); + + void __set_validWriteIdList(const std::string& val); + + void __set_id(const int64_t val); + + void __set_skipColumnSchemaForPartition(const bool val); + + void __set_includeParamKeyPattern(const std::string& val); + + void __set_excludeParamKeyPattern(const std::string& val); + + bool operator == (const PartitionsByExprRequest & rhs) const; + bool operator != (const PartitionsByExprRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PartitionsByExprRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PartitionsByExprRequest &a, PartitionsByExprRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PartitionsByExprRequest& obj); + +typedef struct _TableStatsResult__isset { + _TableStatsResult__isset() : isStatsCompliant(false) {} + bool isStatsCompliant :1; +} _TableStatsResult__isset; + +class TableStatsResult : public virtual ::apache::thrift::TBase { + public: + + TableStatsResult(const TableStatsResult&); + TableStatsResult& operator=(const TableStatsResult&); + TableStatsResult() noexcept; + + virtual ~TableStatsResult() noexcept; + std::vector tableStats; + bool isStatsCompliant; + + _TableStatsResult__isset __isset; + + void __set_tableStats(const std::vector & val); + + void __set_isStatsCompliant(const bool val); + + bool operator == (const TableStatsResult & rhs) const; + bool operator != (const TableStatsResult &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TableStatsResult & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TableStatsResult &a, TableStatsResult &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const TableStatsResult& obj); + +typedef struct _PartitionsStatsResult__isset { + _PartitionsStatsResult__isset() : isStatsCompliant(false) {} + bool isStatsCompliant :1; +} _PartitionsStatsResult__isset; + +class PartitionsStatsResult : public virtual ::apache::thrift::TBase { + public: + + PartitionsStatsResult(const PartitionsStatsResult&); + PartitionsStatsResult& operator=(const PartitionsStatsResult&); + PartitionsStatsResult() noexcept; + + virtual ~PartitionsStatsResult() noexcept; + std::map > partStats; + bool isStatsCompliant; + + _PartitionsStatsResult__isset __isset; + + void __set_partStats(const std::map > & val); + + void __set_isStatsCompliant(const bool val); + + bool operator == (const PartitionsStatsResult & rhs) const; + bool operator != (const PartitionsStatsResult &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PartitionsStatsResult & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PartitionsStatsResult &a, PartitionsStatsResult &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PartitionsStatsResult& obj); + +typedef struct _TableStatsRequest__isset { + _TableStatsRequest__isset() : catName(false), validWriteIdList(false), engine(true), id(true) {} + bool catName :1; + bool validWriteIdList :1; + bool engine :1; + bool id :1; +} _TableStatsRequest__isset; + +class TableStatsRequest : public virtual ::apache::thrift::TBase { + public: + + TableStatsRequest(const TableStatsRequest&); + TableStatsRequest& operator=(const TableStatsRequest&); + TableStatsRequest(); + + virtual ~TableStatsRequest() noexcept; + std::string dbName; + std::string tblName; + std::vector colNames; + std::string catName; + std::string validWriteIdList; + std::string engine; + int64_t id; + + _TableStatsRequest__isset __isset; + + void __set_dbName(const std::string& val); + + void __set_tblName(const std::string& val); + + void __set_colNames(const std::vector & val); + + void __set_catName(const std::string& val); + + void __set_validWriteIdList(const std::string& val); + + void __set_engine(const std::string& val); + + void __set_id(const int64_t val); + + bool operator == (const TableStatsRequest & rhs) const; + bool operator != (const TableStatsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TableStatsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TableStatsRequest &a, TableStatsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const TableStatsRequest& obj); + +typedef struct _PartitionsStatsRequest__isset { + _PartitionsStatsRequest__isset() : catName(false), validWriteIdList(false), engine(true) {} + bool catName :1; + bool validWriteIdList :1; + bool engine :1; +} _PartitionsStatsRequest__isset; + +class PartitionsStatsRequest : public virtual ::apache::thrift::TBase { + public: + + PartitionsStatsRequest(const PartitionsStatsRequest&); + PartitionsStatsRequest& operator=(const PartitionsStatsRequest&); + PartitionsStatsRequest(); + + virtual ~PartitionsStatsRequest() noexcept; + std::string dbName; + std::string tblName; + std::vector colNames; + std::vector partNames; + std::string catName; + std::string validWriteIdList; + std::string engine; + + _PartitionsStatsRequest__isset __isset; + + void __set_dbName(const std::string& val); + + void __set_tblName(const std::string& val); + + void __set_colNames(const std::vector & val); + + void __set_partNames(const std::vector & val); + + void __set_catName(const std::string& val); + + void __set_validWriteIdList(const std::string& val); + + void __set_engine(const std::string& val); + + bool operator == (const PartitionsStatsRequest & rhs) const; + bool operator != (const PartitionsStatsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PartitionsStatsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PartitionsStatsRequest &a, PartitionsStatsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PartitionsStatsRequest& obj); + +typedef struct _AddPartitionsResult__isset { + _AddPartitionsResult__isset() : partitions(false), isStatsCompliant(false), partitionColSchema(false) {} + bool partitions :1; + bool isStatsCompliant :1; + bool partitionColSchema :1; +} _AddPartitionsResult__isset; + +class AddPartitionsResult : public virtual ::apache::thrift::TBase { + public: + + AddPartitionsResult(const AddPartitionsResult&); + AddPartitionsResult& operator=(const AddPartitionsResult&); + AddPartitionsResult() noexcept; + + virtual ~AddPartitionsResult() noexcept; + std::vector partitions; + bool isStatsCompliant; + std::vector partitionColSchema; + + _AddPartitionsResult__isset __isset; + + void __set_partitions(const std::vector & val); + + void __set_isStatsCompliant(const bool val); + + void __set_partitionColSchema(const std::vector & val); + + bool operator == (const AddPartitionsResult & rhs) const; + bool operator != (const AddPartitionsResult &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AddPartitionsResult & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AddPartitionsResult &a, AddPartitionsResult &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AddPartitionsResult& obj); + +typedef struct _AddPartitionsRequest__isset { + _AddPartitionsRequest__isset() : needResult(true), catName(false), validWriteIdList(false), skipColumnSchemaForPartition(false), partitionColSchema(false), environmentContext(false) {} + bool needResult :1; + bool catName :1; + bool validWriteIdList :1; + bool skipColumnSchemaForPartition :1; + bool partitionColSchema :1; + bool environmentContext :1; +} _AddPartitionsRequest__isset; + +class AddPartitionsRequest : public virtual ::apache::thrift::TBase { + public: + + AddPartitionsRequest(const AddPartitionsRequest&); + AddPartitionsRequest& operator=(const AddPartitionsRequest&); + AddPartitionsRequest() noexcept; + + virtual ~AddPartitionsRequest() noexcept; + std::string dbName; + std::string tblName; + std::vector parts; + bool ifNotExists; + bool needResult; + std::string catName; + std::string validWriteIdList; + bool skipColumnSchemaForPartition; + std::vector partitionColSchema; + EnvironmentContext environmentContext; + + _AddPartitionsRequest__isset __isset; + + void __set_dbName(const std::string& val); + + void __set_tblName(const std::string& val); + + void __set_parts(const std::vector & val); + + void __set_ifNotExists(const bool val); + + void __set_needResult(const bool val); + + void __set_catName(const std::string& val); + + void __set_validWriteIdList(const std::string& val); + + void __set_skipColumnSchemaForPartition(const bool val); + + void __set_partitionColSchema(const std::vector & val); + + void __set_environmentContext(const EnvironmentContext& val); + + bool operator == (const AddPartitionsRequest & rhs) const; + bool operator != (const AddPartitionsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AddPartitionsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AddPartitionsRequest &a, AddPartitionsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AddPartitionsRequest& obj); + +typedef struct _DropPartitionsResult__isset { + _DropPartitionsResult__isset() : partitions(false) {} + bool partitions :1; +} _DropPartitionsResult__isset; + +class DropPartitionsResult : public virtual ::apache::thrift::TBase { + public: + + DropPartitionsResult(const DropPartitionsResult&); + DropPartitionsResult& operator=(const DropPartitionsResult&); + DropPartitionsResult() noexcept; + + virtual ~DropPartitionsResult() noexcept; + std::vector partitions; + + _DropPartitionsResult__isset __isset; + + void __set_partitions(const std::vector & val); + + bool operator == (const DropPartitionsResult & rhs) const; + bool operator != (const DropPartitionsResult &rhs) const { + return !(*this == rhs); + } + + bool operator < (const DropPartitionsResult & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(DropPartitionsResult &a, DropPartitionsResult &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const DropPartitionsResult& obj); + +typedef struct _DropPartitionsExpr__isset { + _DropPartitionsExpr__isset() : partArchiveLevel(false) {} + bool partArchiveLevel :1; +} _DropPartitionsExpr__isset; + +class DropPartitionsExpr : public virtual ::apache::thrift::TBase { + public: + + DropPartitionsExpr(const DropPartitionsExpr&); + DropPartitionsExpr& operator=(const DropPartitionsExpr&); + DropPartitionsExpr() noexcept; + + virtual ~DropPartitionsExpr() noexcept; + std::string expr; + int32_t partArchiveLevel; + + _DropPartitionsExpr__isset __isset; + + void __set_expr(const std::string& val); + + void __set_partArchiveLevel(const int32_t val); + + bool operator == (const DropPartitionsExpr & rhs) const; + bool operator != (const DropPartitionsExpr &rhs) const { + return !(*this == rhs); + } + + bool operator < (const DropPartitionsExpr & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(DropPartitionsExpr &a, DropPartitionsExpr &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const DropPartitionsExpr& obj); + +typedef struct _RequestPartsSpec__isset { + _RequestPartsSpec__isset() : names(false), exprs(false) {} + bool names :1; + bool exprs :1; +} _RequestPartsSpec__isset; + +class RequestPartsSpec : public virtual ::apache::thrift::TBase { + public: + + RequestPartsSpec(const RequestPartsSpec&); + RequestPartsSpec& operator=(const RequestPartsSpec&); + RequestPartsSpec() noexcept; + + virtual ~RequestPartsSpec() noexcept; + std::vector names; + std::vector exprs; + + _RequestPartsSpec__isset __isset; + + void __set_names(const std::vector & val); + + void __set_exprs(const std::vector & val); + + bool operator == (const RequestPartsSpec & rhs) const; + bool operator != (const RequestPartsSpec &rhs) const { + return !(*this == rhs); + } + + bool operator < (const RequestPartsSpec & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(RequestPartsSpec &a, RequestPartsSpec &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const RequestPartsSpec& obj); + +typedef struct _DropPartitionsRequest__isset { + _DropPartitionsRequest__isset() : deleteData(false), ifExists(true), ignoreProtection(false), environmentContext(false), needResult(true), catName(false), skipColumnSchemaForPartition(false) {} + bool deleteData :1; + bool ifExists :1; + bool ignoreProtection :1; + bool environmentContext :1; + bool needResult :1; + bool catName :1; + bool skipColumnSchemaForPartition :1; +} _DropPartitionsRequest__isset; + +class DropPartitionsRequest : public virtual ::apache::thrift::TBase { + public: + + DropPartitionsRequest(const DropPartitionsRequest&); + DropPartitionsRequest& operator=(const DropPartitionsRequest&); + DropPartitionsRequest() noexcept; + + virtual ~DropPartitionsRequest() noexcept; + std::string dbName; + std::string tblName; + RequestPartsSpec parts; + bool deleteData; + bool ifExists; + bool ignoreProtection; + EnvironmentContext environmentContext; + bool needResult; + std::string catName; + bool skipColumnSchemaForPartition; + + _DropPartitionsRequest__isset __isset; + + void __set_dbName(const std::string& val); + + void __set_tblName(const std::string& val); + + void __set_parts(const RequestPartsSpec& val); + + void __set_deleteData(const bool val); + + void __set_ifExists(const bool val); + + void __set_ignoreProtection(const bool val); + + void __set_environmentContext(const EnvironmentContext& val); + + void __set_needResult(const bool val); + + void __set_catName(const std::string& val); + + void __set_skipColumnSchemaForPartition(const bool val); + + bool operator == (const DropPartitionsRequest & rhs) const; + bool operator != (const DropPartitionsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const DropPartitionsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(DropPartitionsRequest &a, DropPartitionsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const DropPartitionsRequest& obj); + +typedef struct _DropPartitionRequest__isset { + _DropPartitionRequest__isset() : catName(false), partName(false), partVals(false), deleteData(false), environmentContext(false) {} + bool catName :1; + bool partName :1; + bool partVals :1; + bool deleteData :1; + bool environmentContext :1; +} _DropPartitionRequest__isset; + +class DropPartitionRequest : public virtual ::apache::thrift::TBase { + public: + + DropPartitionRequest(const DropPartitionRequest&); + DropPartitionRequest& operator=(const DropPartitionRequest&); + DropPartitionRequest() noexcept; + + virtual ~DropPartitionRequest() noexcept; + std::string catName; + std::string dbName; + std::string tblName; + std::string partName; + std::vector partVals; + bool deleteData; + EnvironmentContext environmentContext; + + _DropPartitionRequest__isset __isset; + + void __set_catName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_tblName(const std::string& val); + + void __set_partName(const std::string& val); + + void __set_partVals(const std::vector & val); + + void __set_deleteData(const bool val); + + void __set_environmentContext(const EnvironmentContext& val); + + bool operator == (const DropPartitionRequest & rhs) const; + bool operator != (const DropPartitionRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const DropPartitionRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(DropPartitionRequest &a, DropPartitionRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const DropPartitionRequest& obj); + +typedef struct _PartitionValuesRequest__isset { + _PartitionValuesRequest__isset() : applyDistinct(true), filter(false), partitionOrder(false), ascending(true), maxParts(true), catName(false), validWriteIdList(false) {} + bool applyDistinct :1; + bool filter :1; + bool partitionOrder :1; + bool ascending :1; + bool maxParts :1; + bool catName :1; + bool validWriteIdList :1; +} _PartitionValuesRequest__isset; + +class PartitionValuesRequest : public virtual ::apache::thrift::TBase { + public: + + PartitionValuesRequest(const PartitionValuesRequest&); + PartitionValuesRequest& operator=(const PartitionValuesRequest&); + PartitionValuesRequest() noexcept; + + virtual ~PartitionValuesRequest() noexcept; + std::string dbName; + std::string tblName; + std::vector partitionKeys; + bool applyDistinct; + std::string filter; + std::vector partitionOrder; + bool ascending; + int64_t maxParts; + std::string catName; + std::string validWriteIdList; + + _PartitionValuesRequest__isset __isset; + + void __set_dbName(const std::string& val); + + void __set_tblName(const std::string& val); + + void __set_partitionKeys(const std::vector & val); + + void __set_applyDistinct(const bool val); + + void __set_filter(const std::string& val); + + void __set_partitionOrder(const std::vector & val); + + void __set_ascending(const bool val); + + void __set_maxParts(const int64_t val); + + void __set_catName(const std::string& val); + + void __set_validWriteIdList(const std::string& val); + + bool operator == (const PartitionValuesRequest & rhs) const; + bool operator != (const PartitionValuesRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PartitionValuesRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PartitionValuesRequest &a, PartitionValuesRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PartitionValuesRequest& obj); + + +class PartitionValuesRow : public virtual ::apache::thrift::TBase { + public: + + PartitionValuesRow(const PartitionValuesRow&); + PartitionValuesRow& operator=(const PartitionValuesRow&); + PartitionValuesRow() noexcept; + + virtual ~PartitionValuesRow() noexcept; + std::vector row; + + void __set_row(const std::vector & val); + + bool operator == (const PartitionValuesRow & rhs) const; + bool operator != (const PartitionValuesRow &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PartitionValuesRow & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PartitionValuesRow &a, PartitionValuesRow &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PartitionValuesRow& obj); + + +class PartitionValuesResponse : public virtual ::apache::thrift::TBase { + public: + + PartitionValuesResponse(const PartitionValuesResponse&); + PartitionValuesResponse& operator=(const PartitionValuesResponse&); + PartitionValuesResponse() noexcept; + + virtual ~PartitionValuesResponse() noexcept; + std::vector partitionValues; + + void __set_partitionValues(const std::vector & val); + + bool operator == (const PartitionValuesResponse & rhs) const; + bool operator != (const PartitionValuesResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PartitionValuesResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PartitionValuesResponse &a, PartitionValuesResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PartitionValuesResponse& obj); + +typedef struct _GetPartitionsByNamesRequest__isset { + _GetPartitionsByNamesRequest__isset() : names(false), get_col_stats(false), processorCapabilities(false), processorIdentifier(false), engine(true), validWriteIdList(false), getFileMetadata(false), id(true), skipColumnSchemaForPartition(false), includeParamKeyPattern(false), excludeParamKeyPattern(false) {} + bool names :1; + bool get_col_stats :1; + bool processorCapabilities :1; + bool processorIdentifier :1; + bool engine :1; + bool validWriteIdList :1; + bool getFileMetadata :1; + bool id :1; + bool skipColumnSchemaForPartition :1; + bool includeParamKeyPattern :1; + bool excludeParamKeyPattern :1; +} _GetPartitionsByNamesRequest__isset; + +class GetPartitionsByNamesRequest : public virtual ::apache::thrift::TBase { + public: + + GetPartitionsByNamesRequest(const GetPartitionsByNamesRequest&); + GetPartitionsByNamesRequest& operator=(const GetPartitionsByNamesRequest&); + GetPartitionsByNamesRequest(); + + virtual ~GetPartitionsByNamesRequest() noexcept; + std::string db_name; + std::string tbl_name; + std::vector names; + bool get_col_stats; + std::vector processorCapabilities; + std::string processorIdentifier; + std::string engine; + std::string validWriteIdList; + bool getFileMetadata; + int64_t id; + bool skipColumnSchemaForPartition; + std::string includeParamKeyPattern; + std::string excludeParamKeyPattern; + + _GetPartitionsByNamesRequest__isset __isset; + + void __set_db_name(const std::string& val); + + void __set_tbl_name(const std::string& val); + + void __set_names(const std::vector & val); + + void __set_get_col_stats(const bool val); + + void __set_processorCapabilities(const std::vector & val); + + void __set_processorIdentifier(const std::string& val); + + void __set_engine(const std::string& val); + + void __set_validWriteIdList(const std::string& val); + + void __set_getFileMetadata(const bool val); + + void __set_id(const int64_t val); + + void __set_skipColumnSchemaForPartition(const bool val); + + void __set_includeParamKeyPattern(const std::string& val); + + void __set_excludeParamKeyPattern(const std::string& val); + + bool operator == (const GetPartitionsByNamesRequest & rhs) const; + bool operator != (const GetPartitionsByNamesRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetPartitionsByNamesRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetPartitionsByNamesRequest &a, GetPartitionsByNamesRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetPartitionsByNamesRequest& obj); + +typedef struct _GetPartitionsByNamesResult__isset { + _GetPartitionsByNamesResult__isset() : dictionary(false) {} + bool dictionary :1; +} _GetPartitionsByNamesResult__isset; + +class GetPartitionsByNamesResult : public virtual ::apache::thrift::TBase { + public: + + GetPartitionsByNamesResult(const GetPartitionsByNamesResult&); + GetPartitionsByNamesResult& operator=(const GetPartitionsByNamesResult&); + GetPartitionsByNamesResult() noexcept; + + virtual ~GetPartitionsByNamesResult() noexcept; + std::vector partitions; + ObjectDictionary dictionary; + + _GetPartitionsByNamesResult__isset __isset; + + void __set_partitions(const std::vector & val); + + void __set_dictionary(const ObjectDictionary& val); + + bool operator == (const GetPartitionsByNamesResult & rhs) const; + bool operator != (const GetPartitionsByNamesResult &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetPartitionsByNamesResult & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetPartitionsByNamesResult &a, GetPartitionsByNamesResult &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetPartitionsByNamesResult& obj); + +typedef struct _DataConnector__isset { + _DataConnector__isset() : name(false), type(false), url(false), description(false), parameters(false), ownerName(false), ownerType(false), createTime(false) {} + bool name :1; + bool type :1; + bool url :1; + bool description :1; + bool parameters :1; + bool ownerName :1; + bool ownerType :1; + bool createTime :1; +} _DataConnector__isset; + +class DataConnector : public virtual ::apache::thrift::TBase { + public: + + DataConnector(const DataConnector&); + DataConnector& operator=(const DataConnector&); + DataConnector() noexcept; + + virtual ~DataConnector() noexcept; + std::string name; + std::string type; + std::string url; + std::string description; + std::map parameters; + std::string ownerName; + /** + * + * @see PrincipalType + */ + PrincipalType::type ownerType; + int32_t createTime; + + _DataConnector__isset __isset; + + void __set_name(const std::string& val); + + void __set_type(const std::string& val); + + void __set_url(const std::string& val); + + void __set_description(const std::string& val); + + void __set_parameters(const std::map & val); + + void __set_ownerName(const std::string& val); + + void __set_ownerType(const PrincipalType::type val); + + void __set_createTime(const int32_t val); + + bool operator == (const DataConnector & rhs) const; + bool operator != (const DataConnector &rhs) const { + return !(*this == rhs); + } + + bool operator < (const DataConnector & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(DataConnector &a, DataConnector &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const DataConnector& obj); + +typedef struct _ResourceUri__isset { + _ResourceUri__isset() : resourceType(false), uri(false) {} + bool resourceType :1; + bool uri :1; +} _ResourceUri__isset; + +class ResourceUri : public virtual ::apache::thrift::TBase { + public: + + ResourceUri(const ResourceUri&); + ResourceUri& operator=(const ResourceUri&); + ResourceUri() noexcept; + + virtual ~ResourceUri() noexcept; + /** + * + * @see ResourceType + */ + ResourceType::type resourceType; + std::string uri; + + _ResourceUri__isset __isset; + + void __set_resourceType(const ResourceType::type val); + + void __set_uri(const std::string& val); + + bool operator == (const ResourceUri & rhs) const; + bool operator != (const ResourceUri &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ResourceUri & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ResourceUri &a, ResourceUri &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ResourceUri& obj); + +typedef struct _Function__isset { + _Function__isset() : functionName(false), dbName(false), className(false), ownerName(false), ownerType(false), createTime(false), functionType(false), resourceUris(false), catName(false) {} + bool functionName :1; + bool dbName :1; + bool className :1; + bool ownerName :1; + bool ownerType :1; + bool createTime :1; + bool functionType :1; + bool resourceUris :1; + bool catName :1; +} _Function__isset; + +class Function : public virtual ::apache::thrift::TBase { + public: + + Function(const Function&); + Function& operator=(const Function&); + Function() noexcept; + + virtual ~Function() noexcept; + std::string functionName; + std::string dbName; + std::string className; + std::string ownerName; + /** + * + * @see PrincipalType + */ + PrincipalType::type ownerType; + int32_t createTime; + /** + * + * @see FunctionType + */ + FunctionType::type functionType; + std::vector resourceUris; + std::string catName; + + _Function__isset __isset; + + void __set_functionName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_className(const std::string& val); + + void __set_ownerName(const std::string& val); + + void __set_ownerType(const PrincipalType::type val); + + void __set_createTime(const int32_t val); + + void __set_functionType(const FunctionType::type val); + + void __set_resourceUris(const std::vector & val); + + void __set_catName(const std::string& val); + + bool operator == (const Function & rhs) const; + bool operator != (const Function &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Function & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Function &a, Function &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const Function& obj); + +typedef struct _TxnInfo__isset { + _TxnInfo__isset() : agentInfo(true), heartbeatCount(true), metaInfo(false), startedTime(false), lastHeartbeatTime(false) {} + bool agentInfo :1; + bool heartbeatCount :1; + bool metaInfo :1; + bool startedTime :1; + bool lastHeartbeatTime :1; +} _TxnInfo__isset; + +class TxnInfo : public virtual ::apache::thrift::TBase { + public: + + TxnInfo(const TxnInfo&); + TxnInfo& operator=(const TxnInfo&); + TxnInfo(); + + virtual ~TxnInfo() noexcept; + int64_t id; + /** + * + * @see TxnState + */ + TxnState::type state; + std::string user; + std::string hostname; + std::string agentInfo; + int32_t heartbeatCount; + std::string metaInfo; + int64_t startedTime; + int64_t lastHeartbeatTime; + + _TxnInfo__isset __isset; + + void __set_id(const int64_t val); + + void __set_state(const TxnState::type val); + + void __set_user(const std::string& val); + + void __set_hostname(const std::string& val); + + void __set_agentInfo(const std::string& val); + + void __set_heartbeatCount(const int32_t val); + + void __set_metaInfo(const std::string& val); + + void __set_startedTime(const int64_t val); + + void __set_lastHeartbeatTime(const int64_t val); + + bool operator == (const TxnInfo & rhs) const; + bool operator != (const TxnInfo &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TxnInfo & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TxnInfo &a, TxnInfo &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const TxnInfo& obj); + + +class GetOpenTxnsInfoResponse : public virtual ::apache::thrift::TBase { + public: + + GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse&); + GetOpenTxnsInfoResponse& operator=(const GetOpenTxnsInfoResponse&); + GetOpenTxnsInfoResponse() noexcept; + + virtual ~GetOpenTxnsInfoResponse() noexcept; + int64_t txn_high_water_mark; + std::vector open_txns; + + void __set_txn_high_water_mark(const int64_t val); + + void __set_open_txns(const std::vector & val); + + bool operator == (const GetOpenTxnsInfoResponse & rhs) const; + bool operator != (const GetOpenTxnsInfoResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetOpenTxnsInfoResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetOpenTxnsInfoResponse &a, GetOpenTxnsInfoResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetOpenTxnsInfoResponse& obj); + +typedef struct _GetOpenTxnsResponse__isset { + _GetOpenTxnsResponse__isset() : min_open_txn(false) {} + bool min_open_txn :1; +} _GetOpenTxnsResponse__isset; + +class GetOpenTxnsResponse : public virtual ::apache::thrift::TBase { + public: + + GetOpenTxnsResponse(const GetOpenTxnsResponse&); + GetOpenTxnsResponse& operator=(const GetOpenTxnsResponse&); + GetOpenTxnsResponse() noexcept; + + virtual ~GetOpenTxnsResponse() noexcept; + int64_t txn_high_water_mark; + std::vector open_txns; + int64_t min_open_txn; + std::string abortedBits; + + _GetOpenTxnsResponse__isset __isset; + + void __set_txn_high_water_mark(const int64_t val); + + void __set_open_txns(const std::vector & val); + + void __set_min_open_txn(const int64_t val); + + void __set_abortedBits(const std::string& val); + + bool operator == (const GetOpenTxnsResponse & rhs) const; + bool operator != (const GetOpenTxnsResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetOpenTxnsResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetOpenTxnsResponse &a, GetOpenTxnsResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetOpenTxnsResponse& obj); + +typedef struct _OpenTxnRequest__isset { + _OpenTxnRequest__isset() : agentInfo(true), replPolicy(false), replSrcTxnIds(false), txn_type(true) {} + bool agentInfo :1; + bool replPolicy :1; + bool replSrcTxnIds :1; + bool txn_type :1; +} _OpenTxnRequest__isset; + +class OpenTxnRequest : public virtual ::apache::thrift::TBase { + public: + + OpenTxnRequest(const OpenTxnRequest&); + OpenTxnRequest& operator=(const OpenTxnRequest&); + OpenTxnRequest(); + + virtual ~OpenTxnRequest() noexcept; + int32_t num_txns; + std::string user; + std::string hostname; + std::string agentInfo; + std::string replPolicy; + std::vector replSrcTxnIds; + /** + * + * @see TxnType + */ + TxnType::type txn_type; + + _OpenTxnRequest__isset __isset; + + void __set_num_txns(const int32_t val); + + void __set_user(const std::string& val); + + void __set_hostname(const std::string& val); + + void __set_agentInfo(const std::string& val); + + void __set_replPolicy(const std::string& val); + + void __set_replSrcTxnIds(const std::vector & val); + + void __set_txn_type(const TxnType::type val); + + bool operator == (const OpenTxnRequest & rhs) const; + bool operator != (const OpenTxnRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const OpenTxnRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(OpenTxnRequest &a, OpenTxnRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const OpenTxnRequest& obj); + + +class OpenTxnsResponse : public virtual ::apache::thrift::TBase { + public: + + OpenTxnsResponse(const OpenTxnsResponse&); + OpenTxnsResponse& operator=(const OpenTxnsResponse&); + OpenTxnsResponse() noexcept; + + virtual ~OpenTxnsResponse() noexcept; + std::vector txn_ids; + + void __set_txn_ids(const std::vector & val); + + bool operator == (const OpenTxnsResponse & rhs) const; + bool operator != (const OpenTxnsResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const OpenTxnsResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(OpenTxnsResponse &a, OpenTxnsResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const OpenTxnsResponse& obj); + +typedef struct _AbortTxnRequest__isset { + _AbortTxnRequest__isset() : replPolicy(false), txn_type(false), errorCode(false) {} + bool replPolicy :1; + bool txn_type :1; + bool errorCode :1; +} _AbortTxnRequest__isset; + +class AbortTxnRequest : public virtual ::apache::thrift::TBase { + public: + + AbortTxnRequest(const AbortTxnRequest&); + AbortTxnRequest& operator=(const AbortTxnRequest&); + AbortTxnRequest() noexcept; + + virtual ~AbortTxnRequest() noexcept; + int64_t txnid; + std::string replPolicy; + /** + * + * @see TxnType + */ + TxnType::type txn_type; + int64_t errorCode; + + _AbortTxnRequest__isset __isset; + + void __set_txnid(const int64_t val); + + void __set_replPolicy(const std::string& val); + + void __set_txn_type(const TxnType::type val); + + void __set_errorCode(const int64_t val); + + bool operator == (const AbortTxnRequest & rhs) const; + bool operator != (const AbortTxnRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AbortTxnRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AbortTxnRequest &a, AbortTxnRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AbortTxnRequest& obj); + +typedef struct _AbortTxnsRequest__isset { + _AbortTxnsRequest__isset() : errorCode(false) {} + bool errorCode :1; +} _AbortTxnsRequest__isset; + +class AbortTxnsRequest : public virtual ::apache::thrift::TBase { + public: + + AbortTxnsRequest(const AbortTxnsRequest&); + AbortTxnsRequest& operator=(const AbortTxnsRequest&); + AbortTxnsRequest() noexcept; + + virtual ~AbortTxnsRequest() noexcept; + std::vector txn_ids; + int64_t errorCode; + + _AbortTxnsRequest__isset __isset; + + void __set_txn_ids(const std::vector & val); + + void __set_errorCode(const int64_t val); + + bool operator == (const AbortTxnsRequest & rhs) const; + bool operator != (const AbortTxnsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AbortTxnsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AbortTxnsRequest &a, AbortTxnsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AbortTxnsRequest& obj); + + +class CommitTxnKeyValue : public virtual ::apache::thrift::TBase { + public: + + CommitTxnKeyValue(const CommitTxnKeyValue&); + CommitTxnKeyValue& operator=(const CommitTxnKeyValue&); + CommitTxnKeyValue() noexcept; + + virtual ~CommitTxnKeyValue() noexcept; + int64_t tableId; + std::string key; + std::string value; + + void __set_tableId(const int64_t val); + + void __set_key(const std::string& val); + + void __set_value(const std::string& val); + + bool operator == (const CommitTxnKeyValue & rhs) const; + bool operator != (const CommitTxnKeyValue &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CommitTxnKeyValue & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(CommitTxnKeyValue &a, CommitTxnKeyValue &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const CommitTxnKeyValue& obj); + +typedef struct _WriteEventInfo__isset { + _WriteEventInfo__isset() : partition(false), tableObj(false), partitionObj(false) {} + bool partition :1; + bool tableObj :1; + bool partitionObj :1; +} _WriteEventInfo__isset; + +class WriteEventInfo : public virtual ::apache::thrift::TBase { + public: + + WriteEventInfo(const WriteEventInfo&); + WriteEventInfo& operator=(const WriteEventInfo&); + WriteEventInfo() noexcept; + + virtual ~WriteEventInfo() noexcept; + int64_t writeId; + std::string database; + std::string table; + std::string files; + std::string partition; + std::string tableObj; + std::string partitionObj; + + _WriteEventInfo__isset __isset; + + void __set_writeId(const int64_t val); + + void __set_database(const std::string& val); + + void __set_table(const std::string& val); + + void __set_files(const std::string& val); + + void __set_partition(const std::string& val); + + void __set_tableObj(const std::string& val); + + void __set_partitionObj(const std::string& val); + + bool operator == (const WriteEventInfo & rhs) const; + bool operator != (const WriteEventInfo &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WriteEventInfo & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WriteEventInfo &a, WriteEventInfo &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WriteEventInfo& obj); + +typedef struct _ReplLastIdInfo__isset { + _ReplLastIdInfo__isset() : table(false), catalog(false), partitionList(false) {} + bool table :1; + bool catalog :1; + bool partitionList :1; +} _ReplLastIdInfo__isset; + +class ReplLastIdInfo : public virtual ::apache::thrift::TBase { + public: + + ReplLastIdInfo(const ReplLastIdInfo&); + ReplLastIdInfo& operator=(const ReplLastIdInfo&); + ReplLastIdInfo() noexcept; + + virtual ~ReplLastIdInfo() noexcept; + std::string database; + int64_t lastReplId; + std::string table; + std::string catalog; + std::vector partitionList; + + _ReplLastIdInfo__isset __isset; + + void __set_database(const std::string& val); + + void __set_lastReplId(const int64_t val); + + void __set_table(const std::string& val); + + void __set_catalog(const std::string& val); + + void __set_partitionList(const std::vector & val); + + bool operator == (const ReplLastIdInfo & rhs) const; + bool operator != (const ReplLastIdInfo &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ReplLastIdInfo & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ReplLastIdInfo &a, ReplLastIdInfo &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ReplLastIdInfo& obj); + + +class UpdateTransactionalStatsRequest : public virtual ::apache::thrift::TBase { + public: + + UpdateTransactionalStatsRequest(const UpdateTransactionalStatsRequest&) noexcept; + UpdateTransactionalStatsRequest& operator=(const UpdateTransactionalStatsRequest&) noexcept; + UpdateTransactionalStatsRequest() noexcept; + + virtual ~UpdateTransactionalStatsRequest() noexcept; + int64_t tableId; + int64_t insertCount; + int64_t updatedCount; + int64_t deletedCount; + + void __set_tableId(const int64_t val); + + void __set_insertCount(const int64_t val); + + void __set_updatedCount(const int64_t val); + + void __set_deletedCount(const int64_t val); + + bool operator == (const UpdateTransactionalStatsRequest & rhs) const; + bool operator != (const UpdateTransactionalStatsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const UpdateTransactionalStatsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(UpdateTransactionalStatsRequest &a, UpdateTransactionalStatsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const UpdateTransactionalStatsRequest& obj); + +typedef struct _CommitTxnRequest__isset { + _CommitTxnRequest__isset() : replPolicy(false), writeEventInfos(false), replLastIdInfo(false), keyValue(false), exclWriteEnabled(true), txn_type(false) {} + bool replPolicy :1; + bool writeEventInfos :1; + bool replLastIdInfo :1; + bool keyValue :1; + bool exclWriteEnabled :1; + bool txn_type :1; +} _CommitTxnRequest__isset; + +class CommitTxnRequest : public virtual ::apache::thrift::TBase { + public: + + CommitTxnRequest(const CommitTxnRequest&); + CommitTxnRequest& operator=(const CommitTxnRequest&); + CommitTxnRequest() noexcept; + + virtual ~CommitTxnRequest() noexcept; + int64_t txnid; + std::string replPolicy; + std::vector writeEventInfos; + ReplLastIdInfo replLastIdInfo; + CommitTxnKeyValue keyValue; + bool exclWriteEnabled; + /** + * + * @see TxnType + */ + TxnType::type txn_type; + + _CommitTxnRequest__isset __isset; + + void __set_txnid(const int64_t val); + + void __set_replPolicy(const std::string& val); + + void __set_writeEventInfos(const std::vector & val); + + void __set_replLastIdInfo(const ReplLastIdInfo& val); + + void __set_keyValue(const CommitTxnKeyValue& val); + + void __set_exclWriteEnabled(const bool val); + + void __set_txn_type(const TxnType::type val); + + bool operator == (const CommitTxnRequest & rhs) const; + bool operator != (const CommitTxnRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CommitTxnRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(CommitTxnRequest &a, CommitTxnRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const CommitTxnRequest& obj); + +typedef struct _ReplTblWriteIdStateRequest__isset { + _ReplTblWriteIdStateRequest__isset() : partNames(false) {} + bool partNames :1; +} _ReplTblWriteIdStateRequest__isset; + +class ReplTblWriteIdStateRequest : public virtual ::apache::thrift::TBase { + public: + + ReplTblWriteIdStateRequest(const ReplTblWriteIdStateRequest&); + ReplTblWriteIdStateRequest& operator=(const ReplTblWriteIdStateRequest&); + ReplTblWriteIdStateRequest() noexcept; + + virtual ~ReplTblWriteIdStateRequest() noexcept; + std::string validWriteIdlist; + std::string user; + std::string hostName; + std::string dbName; + std::string tableName; + std::vector partNames; + + _ReplTblWriteIdStateRequest__isset __isset; + + void __set_validWriteIdlist(const std::string& val); + + void __set_user(const std::string& val); + + void __set_hostName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_tableName(const std::string& val); + + void __set_partNames(const std::vector & val); + + bool operator == (const ReplTblWriteIdStateRequest & rhs) const; + bool operator != (const ReplTblWriteIdStateRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ReplTblWriteIdStateRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ReplTblWriteIdStateRequest &a, ReplTblWriteIdStateRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ReplTblWriteIdStateRequest& obj); + +typedef struct _GetValidWriteIdsRequest__isset { + _GetValidWriteIdsRequest__isset() : validTxnList(false), writeId(false) {} + bool validTxnList :1; + bool writeId :1; +} _GetValidWriteIdsRequest__isset; + +class GetValidWriteIdsRequest : public virtual ::apache::thrift::TBase { + public: + + GetValidWriteIdsRequest(const GetValidWriteIdsRequest&); + GetValidWriteIdsRequest& operator=(const GetValidWriteIdsRequest&); + GetValidWriteIdsRequest() noexcept; + + virtual ~GetValidWriteIdsRequest() noexcept; + std::vector fullTableNames; + std::string validTxnList; + int64_t writeId; + + _GetValidWriteIdsRequest__isset __isset; + + void __set_fullTableNames(const std::vector & val); + + void __set_validTxnList(const std::string& val); + + void __set_writeId(const int64_t val); + + bool operator == (const GetValidWriteIdsRequest & rhs) const; + bool operator != (const GetValidWriteIdsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetValidWriteIdsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetValidWriteIdsRequest &a, GetValidWriteIdsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetValidWriteIdsRequest& obj); + +typedef struct _TableValidWriteIds__isset { + _TableValidWriteIds__isset() : minOpenWriteId(false) {} + bool minOpenWriteId :1; +} _TableValidWriteIds__isset; + +class TableValidWriteIds : public virtual ::apache::thrift::TBase { + public: + + TableValidWriteIds(const TableValidWriteIds&); + TableValidWriteIds& operator=(const TableValidWriteIds&); + TableValidWriteIds() noexcept; + + virtual ~TableValidWriteIds() noexcept; + std::string fullTableName; + int64_t writeIdHighWaterMark; + std::vector invalidWriteIds; + int64_t minOpenWriteId; + std::string abortedBits; + + _TableValidWriteIds__isset __isset; + + void __set_fullTableName(const std::string& val); + + void __set_writeIdHighWaterMark(const int64_t val); + + void __set_invalidWriteIds(const std::vector & val); + + void __set_minOpenWriteId(const int64_t val); + + void __set_abortedBits(const std::string& val); + + bool operator == (const TableValidWriteIds & rhs) const; + bool operator != (const TableValidWriteIds &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TableValidWriteIds & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TableValidWriteIds &a, TableValidWriteIds &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const TableValidWriteIds& obj); + + +class GetValidWriteIdsResponse : public virtual ::apache::thrift::TBase { + public: + + GetValidWriteIdsResponse(const GetValidWriteIdsResponse&); + GetValidWriteIdsResponse& operator=(const GetValidWriteIdsResponse&); + GetValidWriteIdsResponse() noexcept; + + virtual ~GetValidWriteIdsResponse() noexcept; + std::vector tblValidWriteIds; + + void __set_tblValidWriteIds(const std::vector & val); + + bool operator == (const GetValidWriteIdsResponse & rhs) const; + bool operator != (const GetValidWriteIdsResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetValidWriteIdsResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetValidWriteIdsResponse &a, GetValidWriteIdsResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetValidWriteIdsResponse& obj); + + +class TxnToWriteId : public virtual ::apache::thrift::TBase { + public: + + TxnToWriteId(const TxnToWriteId&) noexcept; + TxnToWriteId& operator=(const TxnToWriteId&) noexcept; + TxnToWriteId() noexcept; + + virtual ~TxnToWriteId() noexcept; + int64_t txnId; + int64_t writeId; + + void __set_txnId(const int64_t val); + + void __set_writeId(const int64_t val); + + bool operator == (const TxnToWriteId & rhs) const; + bool operator != (const TxnToWriteId &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TxnToWriteId & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TxnToWriteId &a, TxnToWriteId &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const TxnToWriteId& obj); + +typedef struct _AllocateTableWriteIdsRequest__isset { + _AllocateTableWriteIdsRequest__isset() : txnIds(false), replPolicy(false), srcTxnToWriteIdList(false), reallocate(true) {} + bool txnIds :1; + bool replPolicy :1; + bool srcTxnToWriteIdList :1; + bool reallocate :1; +} _AllocateTableWriteIdsRequest__isset; + +class AllocateTableWriteIdsRequest : public virtual ::apache::thrift::TBase { + public: + + AllocateTableWriteIdsRequest(const AllocateTableWriteIdsRequest&); + AllocateTableWriteIdsRequest& operator=(const AllocateTableWriteIdsRequest&); + AllocateTableWriteIdsRequest() noexcept; + + virtual ~AllocateTableWriteIdsRequest() noexcept; + std::string dbName; + std::string tableName; + std::vector txnIds; + std::string replPolicy; + std::vector srcTxnToWriteIdList; + bool reallocate; + + _AllocateTableWriteIdsRequest__isset __isset; + + void __set_dbName(const std::string& val); + + void __set_tableName(const std::string& val); + + void __set_txnIds(const std::vector & val); + + void __set_replPolicy(const std::string& val); + + void __set_srcTxnToWriteIdList(const std::vector & val); + + void __set_reallocate(const bool val); + + bool operator == (const AllocateTableWriteIdsRequest & rhs) const; + bool operator != (const AllocateTableWriteIdsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AllocateTableWriteIdsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AllocateTableWriteIdsRequest &a, AllocateTableWriteIdsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AllocateTableWriteIdsRequest& obj); + + +class AllocateTableWriteIdsResponse : public virtual ::apache::thrift::TBase { + public: + + AllocateTableWriteIdsResponse(const AllocateTableWriteIdsResponse&); + AllocateTableWriteIdsResponse& operator=(const AllocateTableWriteIdsResponse&); + AllocateTableWriteIdsResponse() noexcept; + + virtual ~AllocateTableWriteIdsResponse() noexcept; + std::vector txnToWriteIds; + + void __set_txnToWriteIds(const std::vector & val); + + bool operator == (const AllocateTableWriteIdsResponse & rhs) const; + bool operator != (const AllocateTableWriteIdsResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AllocateTableWriteIdsResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AllocateTableWriteIdsResponse &a, AllocateTableWriteIdsResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AllocateTableWriteIdsResponse& obj); + + +class MaxAllocatedTableWriteIdRequest : public virtual ::apache::thrift::TBase { + public: + + MaxAllocatedTableWriteIdRequest(const MaxAllocatedTableWriteIdRequest&); + MaxAllocatedTableWriteIdRequest& operator=(const MaxAllocatedTableWriteIdRequest&); + MaxAllocatedTableWriteIdRequest() noexcept; + + virtual ~MaxAllocatedTableWriteIdRequest() noexcept; + std::string dbName; + std::string tableName; + + void __set_dbName(const std::string& val); + + void __set_tableName(const std::string& val); + + bool operator == (const MaxAllocatedTableWriteIdRequest & rhs) const; + bool operator != (const MaxAllocatedTableWriteIdRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const MaxAllocatedTableWriteIdRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(MaxAllocatedTableWriteIdRequest &a, MaxAllocatedTableWriteIdRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const MaxAllocatedTableWriteIdRequest& obj); + + +class MaxAllocatedTableWriteIdResponse : public virtual ::apache::thrift::TBase { + public: + + MaxAllocatedTableWriteIdResponse(const MaxAllocatedTableWriteIdResponse&) noexcept; + MaxAllocatedTableWriteIdResponse& operator=(const MaxAllocatedTableWriteIdResponse&) noexcept; + MaxAllocatedTableWriteIdResponse() noexcept; + + virtual ~MaxAllocatedTableWriteIdResponse() noexcept; + int64_t maxWriteId; + + void __set_maxWriteId(const int64_t val); + + bool operator == (const MaxAllocatedTableWriteIdResponse & rhs) const; + bool operator != (const MaxAllocatedTableWriteIdResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const MaxAllocatedTableWriteIdResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(MaxAllocatedTableWriteIdResponse &a, MaxAllocatedTableWriteIdResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const MaxAllocatedTableWriteIdResponse& obj); + + +class SeedTableWriteIdsRequest : public virtual ::apache::thrift::TBase { + public: + + SeedTableWriteIdsRequest(const SeedTableWriteIdsRequest&); + SeedTableWriteIdsRequest& operator=(const SeedTableWriteIdsRequest&); + SeedTableWriteIdsRequest() noexcept; + + virtual ~SeedTableWriteIdsRequest() noexcept; + std::string dbName; + std::string tableName; + int64_t seedWriteId; + + void __set_dbName(const std::string& val); + + void __set_tableName(const std::string& val); + + void __set_seedWriteId(const int64_t val); + + bool operator == (const SeedTableWriteIdsRequest & rhs) const; + bool operator != (const SeedTableWriteIdsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SeedTableWriteIdsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(SeedTableWriteIdsRequest &a, SeedTableWriteIdsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const SeedTableWriteIdsRequest& obj); + + +class SeedTxnIdRequest : public virtual ::apache::thrift::TBase { + public: + + SeedTxnIdRequest(const SeedTxnIdRequest&) noexcept; + SeedTxnIdRequest& operator=(const SeedTxnIdRequest&) noexcept; + SeedTxnIdRequest() noexcept; + + virtual ~SeedTxnIdRequest() noexcept; + int64_t seedTxnId; + + void __set_seedTxnId(const int64_t val); + + bool operator == (const SeedTxnIdRequest & rhs) const; + bool operator != (const SeedTxnIdRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SeedTxnIdRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(SeedTxnIdRequest &a, SeedTxnIdRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const SeedTxnIdRequest& obj); + +typedef struct _LockComponent__isset { + _LockComponent__isset() : tablename(false), partitionname(false), operationType(true), isTransactional(true), isDynamicPartitionWrite(true) {} + bool tablename :1; + bool partitionname :1; + bool operationType :1; + bool isTransactional :1; + bool isDynamicPartitionWrite :1; +} _LockComponent__isset; + +class LockComponent : public virtual ::apache::thrift::TBase { + public: + + LockComponent(const LockComponent&); + LockComponent& operator=(const LockComponent&); + LockComponent() noexcept; + + virtual ~LockComponent() noexcept; + /** + * + * @see LockType + */ + LockType::type type; + /** + * + * @see LockLevel + */ + LockLevel::type level; + std::string dbname; + std::string tablename; + std::string partitionname; + /** + * + * @see DataOperationType + */ + DataOperationType::type operationType; + bool isTransactional; + bool isDynamicPartitionWrite; + + _LockComponent__isset __isset; + + void __set_type(const LockType::type val); + + void __set_level(const LockLevel::type val); + + void __set_dbname(const std::string& val); + + void __set_tablename(const std::string& val); + + void __set_partitionname(const std::string& val); + + void __set_operationType(const DataOperationType::type val); + + void __set_isTransactional(const bool val); + + void __set_isDynamicPartitionWrite(const bool val); + + bool operator == (const LockComponent & rhs) const; + bool operator != (const LockComponent &rhs) const { + return !(*this == rhs); + } + + bool operator < (const LockComponent & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(LockComponent &a, LockComponent &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const LockComponent& obj); + +typedef struct _LockRequest__isset { + _LockRequest__isset() : txnid(false), agentInfo(true), zeroWaitReadEnabled(true), exclusiveCTAS(true), locklessReadsEnabled(true) {} + bool txnid :1; + bool agentInfo :1; + bool zeroWaitReadEnabled :1; + bool exclusiveCTAS :1; + bool locklessReadsEnabled :1; +} _LockRequest__isset; + +class LockRequest : public virtual ::apache::thrift::TBase { + public: + + LockRequest(const LockRequest&); + LockRequest& operator=(const LockRequest&); + LockRequest(); + + virtual ~LockRequest() noexcept; + std::vector component; + int64_t txnid; + std::string user; + std::string hostname; + std::string agentInfo; + bool zeroWaitReadEnabled; + bool exclusiveCTAS; + bool locklessReadsEnabled; + + _LockRequest__isset __isset; + + void __set_component(const std::vector & val); + + void __set_txnid(const int64_t val); + + void __set_user(const std::string& val); + + void __set_hostname(const std::string& val); + + void __set_agentInfo(const std::string& val); + + void __set_zeroWaitReadEnabled(const bool val); + + void __set_exclusiveCTAS(const bool val); + + void __set_locklessReadsEnabled(const bool val); + + bool operator == (const LockRequest & rhs) const; + bool operator != (const LockRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const LockRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(LockRequest &a, LockRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const LockRequest& obj); + +typedef struct _LockResponse__isset { + _LockResponse__isset() : errorMessage(false) {} + bool errorMessage :1; +} _LockResponse__isset; + +class LockResponse : public virtual ::apache::thrift::TBase { + public: + + LockResponse(const LockResponse&); + LockResponse& operator=(const LockResponse&); + LockResponse() noexcept; + + virtual ~LockResponse() noexcept; + int64_t lockid; + /** + * + * @see LockState + */ + LockState::type state; + std::string errorMessage; + + _LockResponse__isset __isset; + + void __set_lockid(const int64_t val); + + void __set_state(const LockState::type val); + + void __set_errorMessage(const std::string& val); + + bool operator == (const LockResponse & rhs) const; + bool operator != (const LockResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const LockResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(LockResponse &a, LockResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const LockResponse& obj); + +typedef struct _CheckLockRequest__isset { + _CheckLockRequest__isset() : txnid(false), elapsed_ms(false) {} + bool txnid :1; + bool elapsed_ms :1; +} _CheckLockRequest__isset; + +class CheckLockRequest : public virtual ::apache::thrift::TBase { + public: + + CheckLockRequest(const CheckLockRequest&) noexcept; + CheckLockRequest& operator=(const CheckLockRequest&) noexcept; + CheckLockRequest() noexcept; + + virtual ~CheckLockRequest() noexcept; + int64_t lockid; + int64_t txnid; + int64_t elapsed_ms; + + _CheckLockRequest__isset __isset; + + void __set_lockid(const int64_t val); + + void __set_txnid(const int64_t val); + + void __set_elapsed_ms(const int64_t val); + + bool operator == (const CheckLockRequest & rhs) const; + bool operator != (const CheckLockRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CheckLockRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(CheckLockRequest &a, CheckLockRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const CheckLockRequest& obj); + + +class UnlockRequest : public virtual ::apache::thrift::TBase { + public: + + UnlockRequest(const UnlockRequest&) noexcept; + UnlockRequest& operator=(const UnlockRequest&) noexcept; + UnlockRequest() noexcept; + + virtual ~UnlockRequest() noexcept; + int64_t lockid; + + void __set_lockid(const int64_t val); + + bool operator == (const UnlockRequest & rhs) const; + bool operator != (const UnlockRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const UnlockRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(UnlockRequest &a, UnlockRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const UnlockRequest& obj); + +typedef struct _ShowLocksRequest__isset { + _ShowLocksRequest__isset() : dbname(false), tablename(false), partname(false), isExtended(true), txnid(false) {} + bool dbname :1; + bool tablename :1; + bool partname :1; + bool isExtended :1; + bool txnid :1; +} _ShowLocksRequest__isset; + +class ShowLocksRequest : public virtual ::apache::thrift::TBase { + public: + + ShowLocksRequest(const ShowLocksRequest&); + ShowLocksRequest& operator=(const ShowLocksRequest&); + ShowLocksRequest() noexcept; + + virtual ~ShowLocksRequest() noexcept; + std::string dbname; + std::string tablename; + std::string partname; + bool isExtended; + int64_t txnid; + + _ShowLocksRequest__isset __isset; + + void __set_dbname(const std::string& val); + + void __set_tablename(const std::string& val); + + void __set_partname(const std::string& val); + + void __set_isExtended(const bool val); + + void __set_txnid(const int64_t val); + + bool operator == (const ShowLocksRequest & rhs) const; + bool operator != (const ShowLocksRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ShowLocksRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ShowLocksRequest &a, ShowLocksRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ShowLocksRequest& obj); + +typedef struct _ShowLocksResponseElement__isset { + _ShowLocksResponseElement__isset() : tablename(false), partname(false), txnid(false), acquiredat(false), heartbeatCount(true), agentInfo(false), blockedByExtId(false), blockedByIntId(false), lockIdInternal(false) {} + bool tablename :1; + bool partname :1; + bool txnid :1; + bool acquiredat :1; + bool heartbeatCount :1; + bool agentInfo :1; + bool blockedByExtId :1; + bool blockedByIntId :1; + bool lockIdInternal :1; +} _ShowLocksResponseElement__isset; + +class ShowLocksResponseElement : public virtual ::apache::thrift::TBase { + public: + + ShowLocksResponseElement(const ShowLocksResponseElement&); + ShowLocksResponseElement& operator=(const ShowLocksResponseElement&); + ShowLocksResponseElement() noexcept; + + virtual ~ShowLocksResponseElement() noexcept; + int64_t lockid; + std::string dbname; + std::string tablename; + std::string partname; + /** + * + * @see LockState + */ + LockState::type state; + /** + * + * @see LockType + */ + LockType::type type; + int64_t txnid; + int64_t lastheartbeat; + int64_t acquiredat; + std::string user; + std::string hostname; + int32_t heartbeatCount; + std::string agentInfo; + int64_t blockedByExtId; + int64_t blockedByIntId; + int64_t lockIdInternal; + + _ShowLocksResponseElement__isset __isset; + + void __set_lockid(const int64_t val); + + void __set_dbname(const std::string& val); + + void __set_tablename(const std::string& val); + + void __set_partname(const std::string& val); + + void __set_state(const LockState::type val); + + void __set_type(const LockType::type val); + + void __set_txnid(const int64_t val); + + void __set_lastheartbeat(const int64_t val); + + void __set_acquiredat(const int64_t val); + + void __set_user(const std::string& val); + + void __set_hostname(const std::string& val); + + void __set_heartbeatCount(const int32_t val); + + void __set_agentInfo(const std::string& val); + + void __set_blockedByExtId(const int64_t val); + + void __set_blockedByIntId(const int64_t val); + + void __set_lockIdInternal(const int64_t val); + + bool operator == (const ShowLocksResponseElement & rhs) const; + bool operator != (const ShowLocksResponseElement &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ShowLocksResponseElement & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ShowLocksResponseElement& obj); + +typedef struct _ShowLocksResponse__isset { + _ShowLocksResponse__isset() : locks(false) {} + bool locks :1; +} _ShowLocksResponse__isset; + +class ShowLocksResponse : public virtual ::apache::thrift::TBase { + public: + + ShowLocksResponse(const ShowLocksResponse&); + ShowLocksResponse& operator=(const ShowLocksResponse&); + ShowLocksResponse() noexcept; + + virtual ~ShowLocksResponse() noexcept; + std::vector locks; + + _ShowLocksResponse__isset __isset; + + void __set_locks(const std::vector & val); + + bool operator == (const ShowLocksResponse & rhs) const; + bool operator != (const ShowLocksResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ShowLocksResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ShowLocksResponse &a, ShowLocksResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ShowLocksResponse& obj); + +typedef struct _HeartbeatRequest__isset { + _HeartbeatRequest__isset() : lockid(false), txnid(false) {} + bool lockid :1; + bool txnid :1; +} _HeartbeatRequest__isset; + +class HeartbeatRequest : public virtual ::apache::thrift::TBase { + public: + + HeartbeatRequest(const HeartbeatRequest&) noexcept; + HeartbeatRequest& operator=(const HeartbeatRequest&) noexcept; + HeartbeatRequest() noexcept; + + virtual ~HeartbeatRequest() noexcept; + int64_t lockid; + int64_t txnid; + + _HeartbeatRequest__isset __isset; + + void __set_lockid(const int64_t val); + + void __set_txnid(const int64_t val); + + bool operator == (const HeartbeatRequest & rhs) const; + bool operator != (const HeartbeatRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const HeartbeatRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(HeartbeatRequest &a, HeartbeatRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const HeartbeatRequest& obj); + + +class HeartbeatTxnRangeRequest : public virtual ::apache::thrift::TBase { + public: + + HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest&) noexcept; + HeartbeatTxnRangeRequest& operator=(const HeartbeatTxnRangeRequest&) noexcept; + HeartbeatTxnRangeRequest() noexcept; + + virtual ~HeartbeatTxnRangeRequest() noexcept; + int64_t min; + int64_t max; + + void __set_min(const int64_t val); + + void __set_max(const int64_t val); + + bool operator == (const HeartbeatTxnRangeRequest & rhs) const; + bool operator != (const HeartbeatTxnRangeRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const HeartbeatTxnRangeRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const HeartbeatTxnRangeRequest& obj); + + +class HeartbeatTxnRangeResponse : public virtual ::apache::thrift::TBase { + public: + + HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse&); + HeartbeatTxnRangeResponse& operator=(const HeartbeatTxnRangeResponse&); + HeartbeatTxnRangeResponse() noexcept; + + virtual ~HeartbeatTxnRangeResponse() noexcept; + std::set aborted; + std::set nosuch; + + void __set_aborted(const std::set & val); + + void __set_nosuch(const std::set & val); + + bool operator == (const HeartbeatTxnRangeResponse & rhs) const; + bool operator != (const HeartbeatTxnRangeResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const HeartbeatTxnRangeResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const HeartbeatTxnRangeResponse& obj); + +typedef struct _CompactionRequest__isset { + _CompactionRequest__isset() : partitionname(false), runas(false), properties(false), initiatorId(false), initiatorVersion(false), poolName(false), numberOfBuckets(false), orderByClause(false) {} + bool partitionname :1; + bool runas :1; + bool properties :1; + bool initiatorId :1; + bool initiatorVersion :1; + bool poolName :1; + bool numberOfBuckets :1; + bool orderByClause :1; +} _CompactionRequest__isset; + +class CompactionRequest : public virtual ::apache::thrift::TBase { + public: + + CompactionRequest(const CompactionRequest&); + CompactionRequest& operator=(const CompactionRequest&); + CompactionRequest() noexcept; + + virtual ~CompactionRequest() noexcept; + std::string dbname; + std::string tablename; + std::string partitionname; + /** + * + * @see CompactionType + */ + CompactionType::type type; + std::string runas; + std::map properties; + std::string initiatorId; + std::string initiatorVersion; + std::string poolName; + int32_t numberOfBuckets; + std::string orderByClause; + + _CompactionRequest__isset __isset; + + void __set_dbname(const std::string& val); + + void __set_tablename(const std::string& val); + + void __set_partitionname(const std::string& val); + + void __set_type(const CompactionType::type val); + + void __set_runas(const std::string& val); + + void __set_properties(const std::map & val); + + void __set_initiatorId(const std::string& val); + + void __set_initiatorVersion(const std::string& val); + + void __set_poolName(const std::string& val); + + void __set_numberOfBuckets(const int32_t val); + + void __set_orderByClause(const std::string& val); + + bool operator == (const CompactionRequest & rhs) const; + bool operator != (const CompactionRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CompactionRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(CompactionRequest &a, CompactionRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const CompactionRequest& obj); + +typedef struct _CompactionInfoStruct__isset { + _CompactionInfoStruct__isset() : partitionname(false), runas(false), properties(false), toomanyaborts(false), state(false), workerId(false), start(false), highestWriteId(false), errorMessage(false), hasoldabort(false), enqueueTime(false), retryRetention(false), poolname(false), numberOfBuckets(false), orderByClause(false) {} + bool partitionname :1; + bool runas :1; + bool properties :1; + bool toomanyaborts :1; + bool state :1; + bool workerId :1; + bool start :1; + bool highestWriteId :1; + bool errorMessage :1; + bool hasoldabort :1; + bool enqueueTime :1; + bool retryRetention :1; + bool poolname :1; + bool numberOfBuckets :1; + bool orderByClause :1; +} _CompactionInfoStruct__isset; + +class CompactionInfoStruct : public virtual ::apache::thrift::TBase { + public: + + CompactionInfoStruct(const CompactionInfoStruct&); + CompactionInfoStruct& operator=(const CompactionInfoStruct&); + CompactionInfoStruct() noexcept; + + virtual ~CompactionInfoStruct() noexcept; + int64_t id; + std::string dbname; + std::string tablename; + std::string partitionname; + /** + * + * @see CompactionType + */ + CompactionType::type type; + std::string runas; + std::string properties; + bool toomanyaborts; + std::string state; + std::string workerId; + int64_t start; + int64_t highestWriteId; + std::string errorMessage; + bool hasoldabort; + int64_t enqueueTime; + int64_t retryRetention; + std::string poolname; + int32_t numberOfBuckets; + std::string orderByClause; + + _CompactionInfoStruct__isset __isset; + + void __set_id(const int64_t val); + + void __set_dbname(const std::string& val); + + void __set_tablename(const std::string& val); + + void __set_partitionname(const std::string& val); + + void __set_type(const CompactionType::type val); + + void __set_runas(const std::string& val); + + void __set_properties(const std::string& val); + + void __set_toomanyaborts(const bool val); + + void __set_state(const std::string& val); + + void __set_workerId(const std::string& val); + + void __set_start(const int64_t val); + + void __set_highestWriteId(const int64_t val); + + void __set_errorMessage(const std::string& val); + + void __set_hasoldabort(const bool val); + + void __set_enqueueTime(const int64_t val); + + void __set_retryRetention(const int64_t val); + + void __set_poolname(const std::string& val); + + void __set_numberOfBuckets(const int32_t val); + + void __set_orderByClause(const std::string& val); + + bool operator == (const CompactionInfoStruct & rhs) const; + bool operator != (const CompactionInfoStruct &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CompactionInfoStruct & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(CompactionInfoStruct &a, CompactionInfoStruct &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const CompactionInfoStruct& obj); + +typedef struct _OptionalCompactionInfoStruct__isset { + _OptionalCompactionInfoStruct__isset() : ci(false) {} + bool ci :1; +} _OptionalCompactionInfoStruct__isset; + +class OptionalCompactionInfoStruct : public virtual ::apache::thrift::TBase { + public: + + OptionalCompactionInfoStruct(const OptionalCompactionInfoStruct&); + OptionalCompactionInfoStruct& operator=(const OptionalCompactionInfoStruct&); + OptionalCompactionInfoStruct() noexcept; + + virtual ~OptionalCompactionInfoStruct() noexcept; + CompactionInfoStruct ci; + + _OptionalCompactionInfoStruct__isset __isset; + + void __set_ci(const CompactionInfoStruct& val); + + bool operator == (const OptionalCompactionInfoStruct & rhs) const; + bool operator != (const OptionalCompactionInfoStruct &rhs) const { + return !(*this == rhs); + } + + bool operator < (const OptionalCompactionInfoStruct & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(OptionalCompactionInfoStruct &a, OptionalCompactionInfoStruct &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const OptionalCompactionInfoStruct& obj); + +typedef struct _CompactionMetricsDataStruct__isset { + _CompactionMetricsDataStruct__isset() : partitionname(false) {} + bool partitionname :1; +} _CompactionMetricsDataStruct__isset; + +class CompactionMetricsDataStruct : public virtual ::apache::thrift::TBase { + public: + + CompactionMetricsDataStruct(const CompactionMetricsDataStruct&); + CompactionMetricsDataStruct& operator=(const CompactionMetricsDataStruct&); + CompactionMetricsDataStruct() noexcept; + + virtual ~CompactionMetricsDataStruct() noexcept; + std::string dbname; + std::string tblname; + std::string partitionname; + /** + * + * @see CompactionMetricsMetricType + */ + CompactionMetricsMetricType::type type; + int32_t metricvalue; + int32_t version; + int32_t threshold; + + _CompactionMetricsDataStruct__isset __isset; + + void __set_dbname(const std::string& val); + + void __set_tblname(const std::string& val); + + void __set_partitionname(const std::string& val); + + void __set_type(const CompactionMetricsMetricType::type val); + + void __set_metricvalue(const int32_t val); + + void __set_version(const int32_t val); + + void __set_threshold(const int32_t val); + + bool operator == (const CompactionMetricsDataStruct & rhs) const; + bool operator != (const CompactionMetricsDataStruct &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CompactionMetricsDataStruct & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(CompactionMetricsDataStruct &a, CompactionMetricsDataStruct &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const CompactionMetricsDataStruct& obj); + +typedef struct _CompactionMetricsDataResponse__isset { + _CompactionMetricsDataResponse__isset() : data(false) {} + bool data :1; +} _CompactionMetricsDataResponse__isset; + +class CompactionMetricsDataResponse : public virtual ::apache::thrift::TBase { + public: + + CompactionMetricsDataResponse(const CompactionMetricsDataResponse&); + CompactionMetricsDataResponse& operator=(const CompactionMetricsDataResponse&); + CompactionMetricsDataResponse() noexcept; + + virtual ~CompactionMetricsDataResponse() noexcept; + CompactionMetricsDataStruct data; + + _CompactionMetricsDataResponse__isset __isset; + + void __set_data(const CompactionMetricsDataStruct& val); + + bool operator == (const CompactionMetricsDataResponse & rhs) const; + bool operator != (const CompactionMetricsDataResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CompactionMetricsDataResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(CompactionMetricsDataResponse &a, CompactionMetricsDataResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const CompactionMetricsDataResponse& obj); + +typedef struct _CompactionMetricsDataRequest__isset { + _CompactionMetricsDataRequest__isset() : partitionName(false) {} + bool partitionName :1; +} _CompactionMetricsDataRequest__isset; + +class CompactionMetricsDataRequest : public virtual ::apache::thrift::TBase { + public: + + CompactionMetricsDataRequest(const CompactionMetricsDataRequest&); + CompactionMetricsDataRequest& operator=(const CompactionMetricsDataRequest&); + CompactionMetricsDataRequest() noexcept; + + virtual ~CompactionMetricsDataRequest() noexcept; + std::string dbName; + std::string tblName; + std::string partitionName; + /** + * + * @see CompactionMetricsMetricType + */ + CompactionMetricsMetricType::type type; + + _CompactionMetricsDataRequest__isset __isset; + + void __set_dbName(const std::string& val); + + void __set_tblName(const std::string& val); + + void __set_partitionName(const std::string& val); + + void __set_type(const CompactionMetricsMetricType::type val); + + bool operator == (const CompactionMetricsDataRequest & rhs) const; + bool operator != (const CompactionMetricsDataRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CompactionMetricsDataRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(CompactionMetricsDataRequest &a, CompactionMetricsDataRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const CompactionMetricsDataRequest& obj); + +typedef struct _CompactionResponse__isset { + _CompactionResponse__isset() : errormessage(false) {} + bool errormessage :1; +} _CompactionResponse__isset; + +class CompactionResponse : public virtual ::apache::thrift::TBase { + public: + + CompactionResponse(const CompactionResponse&); + CompactionResponse& operator=(const CompactionResponse&); + CompactionResponse() noexcept; + + virtual ~CompactionResponse() noexcept; + int64_t id; + std::string state; + bool accepted; + std::string errormessage; + + _CompactionResponse__isset __isset; + + void __set_id(const int64_t val); + + void __set_state(const std::string& val); + + void __set_accepted(const bool val); + + void __set_errormessage(const std::string& val); + + bool operator == (const CompactionResponse & rhs) const; + bool operator != (const CompactionResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CompactionResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(CompactionResponse &a, CompactionResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const CompactionResponse& obj); + +typedef struct _ShowCompactRequest__isset { + _ShowCompactRequest__isset() : id(false), poolName(false), dbName(false), tbName(false), partName(false), type(false), state(false), limit(false), order(false) {} + bool id :1; + bool poolName :1; + bool dbName :1; + bool tbName :1; + bool partName :1; + bool type :1; + bool state :1; + bool limit :1; + bool order :1; +} _ShowCompactRequest__isset; + +class ShowCompactRequest : public virtual ::apache::thrift::TBase { + public: + + ShowCompactRequest(const ShowCompactRequest&); + ShowCompactRequest& operator=(const ShowCompactRequest&); + ShowCompactRequest() noexcept; + + virtual ~ShowCompactRequest() noexcept; + int64_t id; + std::string poolName; + std::string dbName; + std::string tbName; + std::string partName; + /** + * + * @see CompactionType + */ + CompactionType::type type; + std::string state; + int64_t limit; + std::string order; + + _ShowCompactRequest__isset __isset; + + void __set_id(const int64_t val); + + void __set_poolName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_tbName(const std::string& val); + + void __set_partName(const std::string& val); + + void __set_type(const CompactionType::type val); + + void __set_state(const std::string& val); + + void __set_limit(const int64_t val); + + void __set_order(const std::string& val); + + bool operator == (const ShowCompactRequest & rhs) const; + bool operator != (const ShowCompactRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ShowCompactRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ShowCompactRequest &a, ShowCompactRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ShowCompactRequest& obj); + +typedef struct _ShowCompactResponseElement__isset { + _ShowCompactResponseElement__isset() : partitionname(false), workerid(false), start(false), runAs(false), hightestTxnId(false), metaInfo(false), endTime(false), hadoopJobId(true), id(false), errorMessage(false), enqueueTime(false), workerVersion(false), initiatorId(false), initiatorVersion(false), cleanerStart(false), poolName(false), nextTxnId(false), txnId(false), commitTime(false), hightestWriteId(false) {} + bool partitionname :1; + bool workerid :1; + bool start :1; + bool runAs :1; + bool hightestTxnId :1; + bool metaInfo :1; + bool endTime :1; + bool hadoopJobId :1; + bool id :1; + bool errorMessage :1; + bool enqueueTime :1; + bool workerVersion :1; + bool initiatorId :1; + bool initiatorVersion :1; + bool cleanerStart :1; + bool poolName :1; + bool nextTxnId :1; + bool txnId :1; + bool commitTime :1; + bool hightestWriteId :1; +} _ShowCompactResponseElement__isset; + +class ShowCompactResponseElement : public virtual ::apache::thrift::TBase { + public: + + ShowCompactResponseElement(const ShowCompactResponseElement&); + ShowCompactResponseElement& operator=(const ShowCompactResponseElement&); + ShowCompactResponseElement(); + + virtual ~ShowCompactResponseElement() noexcept; + std::string dbname; + std::string tablename; + std::string partitionname; + /** + * + * @see CompactionType + */ + CompactionType::type type; + std::string state; + std::string workerid; + int64_t start; + std::string runAs; + int64_t hightestTxnId; + std::string metaInfo; + int64_t endTime; + std::string hadoopJobId; + int64_t id; + std::string errorMessage; + int64_t enqueueTime; + std::string workerVersion; + std::string initiatorId; + std::string initiatorVersion; + int64_t cleanerStart; + std::string poolName; + int64_t nextTxnId; + int64_t txnId; + int64_t commitTime; + int64_t hightestWriteId; + + _ShowCompactResponseElement__isset __isset; + + void __set_dbname(const std::string& val); + + void __set_tablename(const std::string& val); + + void __set_partitionname(const std::string& val); + + void __set_type(const CompactionType::type val); + + void __set_state(const std::string& val); + + void __set_workerid(const std::string& val); + + void __set_start(const int64_t val); + + void __set_runAs(const std::string& val); + + void __set_hightestTxnId(const int64_t val); + + void __set_metaInfo(const std::string& val); + + void __set_endTime(const int64_t val); + + void __set_hadoopJobId(const std::string& val); + + void __set_id(const int64_t val); + + void __set_errorMessage(const std::string& val); + + void __set_enqueueTime(const int64_t val); + + void __set_workerVersion(const std::string& val); + + void __set_initiatorId(const std::string& val); + + void __set_initiatorVersion(const std::string& val); + + void __set_cleanerStart(const int64_t val); + + void __set_poolName(const std::string& val); + + void __set_nextTxnId(const int64_t val); + + void __set_txnId(const int64_t val); + + void __set_commitTime(const int64_t val); + + void __set_hightestWriteId(const int64_t val); + + bool operator == (const ShowCompactResponseElement & rhs) const; + bool operator != (const ShowCompactResponseElement &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ShowCompactResponseElement & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ShowCompactResponseElement& obj); + + +class ShowCompactResponse : public virtual ::apache::thrift::TBase { + public: + + ShowCompactResponse(const ShowCompactResponse&); + ShowCompactResponse& operator=(const ShowCompactResponse&); + ShowCompactResponse() noexcept; + + virtual ~ShowCompactResponse() noexcept; + std::vector compacts; + + void __set_compacts(const std::vector & val); + + bool operator == (const ShowCompactResponse & rhs) const; + bool operator != (const ShowCompactResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ShowCompactResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ShowCompactResponse &a, ShowCompactResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ShowCompactResponse& obj); + +typedef struct _AbortCompactionRequest__isset { + _AbortCompactionRequest__isset() : type(false), poolName(false) {} + bool type :1; + bool poolName :1; +} _AbortCompactionRequest__isset; + +class AbortCompactionRequest : public virtual ::apache::thrift::TBase { + public: + + AbortCompactionRequest(const AbortCompactionRequest&); + AbortCompactionRequest& operator=(const AbortCompactionRequest&); + AbortCompactionRequest() noexcept; + + virtual ~AbortCompactionRequest() noexcept; + std::vector compactionIds; + std::string type; + std::string poolName; + + _AbortCompactionRequest__isset __isset; + + void __set_compactionIds(const std::vector & val); + + void __set_type(const std::string& val); + + void __set_poolName(const std::string& val); + + bool operator == (const AbortCompactionRequest & rhs) const; + bool operator != (const AbortCompactionRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AbortCompactionRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AbortCompactionRequest &a, AbortCompactionRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AbortCompactionRequest& obj); + +typedef struct _AbortCompactionResponseElement__isset { + _AbortCompactionResponseElement__isset() : status(false), message(false) {} + bool status :1; + bool message :1; +} _AbortCompactionResponseElement__isset; + +class AbortCompactionResponseElement : public virtual ::apache::thrift::TBase { + public: + + AbortCompactionResponseElement(const AbortCompactionResponseElement&); + AbortCompactionResponseElement& operator=(const AbortCompactionResponseElement&); + AbortCompactionResponseElement() noexcept; + + virtual ~AbortCompactionResponseElement() noexcept; + int64_t compactionId; + std::string status; + std::string message; + + _AbortCompactionResponseElement__isset __isset; + + void __set_compactionId(const int64_t val); + + void __set_status(const std::string& val); + + void __set_message(const std::string& val); + + bool operator == (const AbortCompactionResponseElement & rhs) const; + bool operator != (const AbortCompactionResponseElement &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AbortCompactionResponseElement & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AbortCompactionResponseElement &a, AbortCompactionResponseElement &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AbortCompactionResponseElement& obj); + + +class AbortCompactResponse : public virtual ::apache::thrift::TBase { + public: + + AbortCompactResponse(const AbortCompactResponse&); + AbortCompactResponse& operator=(const AbortCompactResponse&); + AbortCompactResponse() noexcept; + + virtual ~AbortCompactResponse() noexcept; + std::map abortedcompacts; + + void __set_abortedcompacts(const std::map & val); + + bool operator == (const AbortCompactResponse & rhs) const; + bool operator != (const AbortCompactResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AbortCompactResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AbortCompactResponse &a, AbortCompactResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AbortCompactResponse& obj); + +typedef struct _GetLatestCommittedCompactionInfoRequest__isset { + _GetLatestCommittedCompactionInfoRequest__isset() : partitionnames(false), lastCompactionId(false) {} + bool partitionnames :1; + bool lastCompactionId :1; +} _GetLatestCommittedCompactionInfoRequest__isset; + +class GetLatestCommittedCompactionInfoRequest : public virtual ::apache::thrift::TBase { + public: + + GetLatestCommittedCompactionInfoRequest(const GetLatestCommittedCompactionInfoRequest&); + GetLatestCommittedCompactionInfoRequest& operator=(const GetLatestCommittedCompactionInfoRequest&); + GetLatestCommittedCompactionInfoRequest() noexcept; + + virtual ~GetLatestCommittedCompactionInfoRequest() noexcept; + std::string dbname; + std::string tablename; + std::vector partitionnames; + int64_t lastCompactionId; + + _GetLatestCommittedCompactionInfoRequest__isset __isset; + + void __set_dbname(const std::string& val); + + void __set_tablename(const std::string& val); + + void __set_partitionnames(const std::vector & val); + + void __set_lastCompactionId(const int64_t val); + + bool operator == (const GetLatestCommittedCompactionInfoRequest & rhs) const; + bool operator != (const GetLatestCommittedCompactionInfoRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetLatestCommittedCompactionInfoRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetLatestCommittedCompactionInfoRequest &a, GetLatestCommittedCompactionInfoRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetLatestCommittedCompactionInfoRequest& obj); + + +class GetLatestCommittedCompactionInfoResponse : public virtual ::apache::thrift::TBase { + public: + + GetLatestCommittedCompactionInfoResponse(const GetLatestCommittedCompactionInfoResponse&); + GetLatestCommittedCompactionInfoResponse& operator=(const GetLatestCommittedCompactionInfoResponse&); + GetLatestCommittedCompactionInfoResponse() noexcept; + + virtual ~GetLatestCommittedCompactionInfoResponse() noexcept; + std::vector compactions; + + void __set_compactions(const std::vector & val); + + bool operator == (const GetLatestCommittedCompactionInfoResponse & rhs) const; + bool operator != (const GetLatestCommittedCompactionInfoResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetLatestCommittedCompactionInfoResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetLatestCommittedCompactionInfoResponse &a, GetLatestCommittedCompactionInfoResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetLatestCommittedCompactionInfoResponse& obj); + +typedef struct _FindNextCompactRequest__isset { + _FindNextCompactRequest__isset() : workerId(false), workerVersion(false), poolName(false) {} + bool workerId :1; + bool workerVersion :1; + bool poolName :1; +} _FindNextCompactRequest__isset; + +class FindNextCompactRequest : public virtual ::apache::thrift::TBase { + public: + + FindNextCompactRequest(const FindNextCompactRequest&); + FindNextCompactRequest& operator=(const FindNextCompactRequest&); + FindNextCompactRequest() noexcept; + + virtual ~FindNextCompactRequest() noexcept; + std::string workerId; + std::string workerVersion; + std::string poolName; + + _FindNextCompactRequest__isset __isset; + + void __set_workerId(const std::string& val); + + void __set_workerVersion(const std::string& val); + + void __set_poolName(const std::string& val); + + bool operator == (const FindNextCompactRequest & rhs) const; + bool operator != (const FindNextCompactRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FindNextCompactRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(FindNextCompactRequest &a, FindNextCompactRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const FindNextCompactRequest& obj); + +typedef struct _AddDynamicPartitions__isset { + _AddDynamicPartitions__isset() : operationType(true) {} + bool operationType :1; +} _AddDynamicPartitions__isset; + +class AddDynamicPartitions : public virtual ::apache::thrift::TBase { + public: + + AddDynamicPartitions(const AddDynamicPartitions&); + AddDynamicPartitions& operator=(const AddDynamicPartitions&); + AddDynamicPartitions() noexcept; + + virtual ~AddDynamicPartitions() noexcept; + int64_t txnid; + int64_t writeid; + std::string dbname; + std::string tablename; + std::vector partitionnames; + /** + * + * @see DataOperationType + */ + DataOperationType::type operationType; + + _AddDynamicPartitions__isset __isset; + + void __set_txnid(const int64_t val); + + void __set_writeid(const int64_t val); + + void __set_dbname(const std::string& val); + + void __set_tablename(const std::string& val); + + void __set_partitionnames(const std::vector & val); + + void __set_operationType(const DataOperationType::type val); + + bool operator == (const AddDynamicPartitions & rhs) const; + bool operator != (const AddDynamicPartitions &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AddDynamicPartitions & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AddDynamicPartitions& obj); + +typedef struct _BasicTxnInfo__isset { + _BasicTxnInfo__isset() : time(false), txnid(false), dbname(false), tablename(false), partitionname(false) {} + bool time :1; + bool txnid :1; + bool dbname :1; + bool tablename :1; + bool partitionname :1; +} _BasicTxnInfo__isset; + +class BasicTxnInfo : public virtual ::apache::thrift::TBase { + public: + + BasicTxnInfo(const BasicTxnInfo&); + BasicTxnInfo& operator=(const BasicTxnInfo&); + BasicTxnInfo() noexcept; + + virtual ~BasicTxnInfo() noexcept; + bool isnull; + int64_t time; + int64_t txnid; + std::string dbname; + std::string tablename; + std::string partitionname; + + _BasicTxnInfo__isset __isset; + + void __set_isnull(const bool val); + + void __set_time(const int64_t val); + + void __set_txnid(const int64_t val); + + void __set_dbname(const std::string& val); + + void __set_tablename(const std::string& val); + + void __set_partitionname(const std::string& val); + + bool operator == (const BasicTxnInfo & rhs) const; + bool operator != (const BasicTxnInfo &rhs) const { + return !(*this == rhs); + } + + bool operator < (const BasicTxnInfo & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(BasicTxnInfo &a, BasicTxnInfo &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const BasicTxnInfo& obj); + +typedef struct _NotificationEventRequest__isset { + _NotificationEventRequest__isset() : maxEvents(false), eventTypeSkipList(false), catName(false), dbName(false), tableNames(false) {} + bool maxEvents :1; + bool eventTypeSkipList :1; + bool catName :1; + bool dbName :1; + bool tableNames :1; +} _NotificationEventRequest__isset; + +class NotificationEventRequest : public virtual ::apache::thrift::TBase { + public: + + NotificationEventRequest(const NotificationEventRequest&); + NotificationEventRequest& operator=(const NotificationEventRequest&); + NotificationEventRequest() noexcept; + + virtual ~NotificationEventRequest() noexcept; + int64_t lastEvent; + int32_t maxEvents; + std::vector eventTypeSkipList; + std::string catName; + std::string dbName; + std::vector tableNames; + + _NotificationEventRequest__isset __isset; + + void __set_lastEvent(const int64_t val); + + void __set_maxEvents(const int32_t val); + + void __set_eventTypeSkipList(const std::vector & val); + + void __set_catName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_tableNames(const std::vector & val); + + bool operator == (const NotificationEventRequest & rhs) const; + bool operator != (const NotificationEventRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const NotificationEventRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(NotificationEventRequest &a, NotificationEventRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const NotificationEventRequest& obj); + +typedef struct _NotificationEvent__isset { + _NotificationEvent__isset() : dbName(false), tableName(false), messageFormat(false), catName(false) {} + bool dbName :1; + bool tableName :1; + bool messageFormat :1; + bool catName :1; +} _NotificationEvent__isset; + +class NotificationEvent : public virtual ::apache::thrift::TBase { + public: + + NotificationEvent(const NotificationEvent&); + NotificationEvent& operator=(const NotificationEvent&); + NotificationEvent() noexcept; + + virtual ~NotificationEvent() noexcept; + int64_t eventId; + int32_t eventTime; + std::string eventType; + std::string dbName; + std::string tableName; + std::string message; + std::string messageFormat; + std::string catName; + + _NotificationEvent__isset __isset; + + void __set_eventId(const int64_t val); + + void __set_eventTime(const int32_t val); + + void __set_eventType(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_tableName(const std::string& val); + + void __set_message(const std::string& val); + + void __set_messageFormat(const std::string& val); + + void __set_catName(const std::string& val); + + bool operator == (const NotificationEvent & rhs) const; + bool operator != (const NotificationEvent &rhs) const { + return !(*this == rhs); + } + + bool operator < (const NotificationEvent & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(NotificationEvent &a, NotificationEvent &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const NotificationEvent& obj); + + +class NotificationEventResponse : public virtual ::apache::thrift::TBase { + public: + + NotificationEventResponse(const NotificationEventResponse&); + NotificationEventResponse& operator=(const NotificationEventResponse&); + NotificationEventResponse() noexcept; + + virtual ~NotificationEventResponse() noexcept; + std::vector events; + + void __set_events(const std::vector & val); + + bool operator == (const NotificationEventResponse & rhs) const; + bool operator != (const NotificationEventResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const NotificationEventResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(NotificationEventResponse &a, NotificationEventResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const NotificationEventResponse& obj); + + +class CurrentNotificationEventId : public virtual ::apache::thrift::TBase { + public: + + CurrentNotificationEventId(const CurrentNotificationEventId&) noexcept; + CurrentNotificationEventId& operator=(const CurrentNotificationEventId&) noexcept; + CurrentNotificationEventId() noexcept; + + virtual ~CurrentNotificationEventId() noexcept; + int64_t eventId; + + void __set_eventId(const int64_t val); + + bool operator == (const CurrentNotificationEventId & rhs) const; + bool operator != (const CurrentNotificationEventId &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CurrentNotificationEventId & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const CurrentNotificationEventId& obj); + +typedef struct _NotificationEventsCountRequest__isset { + _NotificationEventsCountRequest__isset() : catName(false), toEventId(false), limit(false), tableNames(false) {} + bool catName :1; + bool toEventId :1; + bool limit :1; + bool tableNames :1; +} _NotificationEventsCountRequest__isset; + +class NotificationEventsCountRequest : public virtual ::apache::thrift::TBase { + public: + + NotificationEventsCountRequest(const NotificationEventsCountRequest&); + NotificationEventsCountRequest& operator=(const NotificationEventsCountRequest&); + NotificationEventsCountRequest() noexcept; + + virtual ~NotificationEventsCountRequest() noexcept; + int64_t fromEventId; + std::string dbName; + std::string catName; + int64_t toEventId; + int64_t limit; + std::vector tableNames; + + _NotificationEventsCountRequest__isset __isset; + + void __set_fromEventId(const int64_t val); + + void __set_dbName(const std::string& val); + + void __set_catName(const std::string& val); + + void __set_toEventId(const int64_t val); + + void __set_limit(const int64_t val); + + void __set_tableNames(const std::vector & val); + + bool operator == (const NotificationEventsCountRequest & rhs) const; + bool operator != (const NotificationEventsCountRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const NotificationEventsCountRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(NotificationEventsCountRequest &a, NotificationEventsCountRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const NotificationEventsCountRequest& obj); + + +class NotificationEventsCountResponse : public virtual ::apache::thrift::TBase { + public: + + NotificationEventsCountResponse(const NotificationEventsCountResponse&) noexcept; + NotificationEventsCountResponse& operator=(const NotificationEventsCountResponse&) noexcept; + NotificationEventsCountResponse() noexcept; + + virtual ~NotificationEventsCountResponse() noexcept; + int64_t eventsCount; + + void __set_eventsCount(const int64_t val); + + bool operator == (const NotificationEventsCountResponse & rhs) const; + bool operator != (const NotificationEventsCountResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const NotificationEventsCountResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(NotificationEventsCountResponse &a, NotificationEventsCountResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const NotificationEventsCountResponse& obj); + +typedef struct _InsertEventRequestData__isset { + _InsertEventRequestData__isset() : replace(false), filesAddedChecksum(false), subDirectoryList(false), partitionVal(false) {} + bool replace :1; + bool filesAddedChecksum :1; + bool subDirectoryList :1; + bool partitionVal :1; +} _InsertEventRequestData__isset; + +class InsertEventRequestData : public virtual ::apache::thrift::TBase { + public: + + InsertEventRequestData(const InsertEventRequestData&); + InsertEventRequestData& operator=(const InsertEventRequestData&); + InsertEventRequestData() noexcept; + + virtual ~InsertEventRequestData() noexcept; + bool replace; + std::vector filesAdded; + std::vector filesAddedChecksum; + std::vector subDirectoryList; + std::vector partitionVal; + + _InsertEventRequestData__isset __isset; + + void __set_replace(const bool val); + + void __set_filesAdded(const std::vector & val); + + void __set_filesAddedChecksum(const std::vector & val); + + void __set_subDirectoryList(const std::vector & val); + + void __set_partitionVal(const std::vector & val); + + bool operator == (const InsertEventRequestData & rhs) const; + bool operator != (const InsertEventRequestData &rhs) const { + return !(*this == rhs); + } + + bool operator < (const InsertEventRequestData & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(InsertEventRequestData &a, InsertEventRequestData &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const InsertEventRequestData& obj); + +typedef struct _FireEventRequestData__isset { + _FireEventRequestData__isset() : insertData(false), insertDatas(false), refreshEvent(false) {} + bool insertData :1; + bool insertDatas :1; + bool refreshEvent :1; +} _FireEventRequestData__isset; + +class FireEventRequestData : public virtual ::apache::thrift::TBase { + public: + + FireEventRequestData(const FireEventRequestData&); + FireEventRequestData& operator=(const FireEventRequestData&); + FireEventRequestData() noexcept; + + virtual ~FireEventRequestData() noexcept; + InsertEventRequestData insertData; + std::vector insertDatas; + bool refreshEvent; + + _FireEventRequestData__isset __isset; + + void __set_insertData(const InsertEventRequestData& val); + + void __set_insertDatas(const std::vector & val); + + void __set_refreshEvent(const bool val); + + bool operator == (const FireEventRequestData & rhs) const; + bool operator != (const FireEventRequestData &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FireEventRequestData & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(FireEventRequestData &a, FireEventRequestData &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const FireEventRequestData& obj); + +typedef struct _FireEventRequest__isset { + _FireEventRequest__isset() : dbName(false), tableName(false), partitionVals(false), catName(false), tblParams(false) {} + bool dbName :1; + bool tableName :1; + bool partitionVals :1; + bool catName :1; + bool tblParams :1; +} _FireEventRequest__isset; + +class FireEventRequest : public virtual ::apache::thrift::TBase { + public: + + FireEventRequest(const FireEventRequest&); + FireEventRequest& operator=(const FireEventRequest&); + FireEventRequest() noexcept; + + virtual ~FireEventRequest() noexcept; + bool successful; + FireEventRequestData data; + std::string dbName; + std::string tableName; + std::vector partitionVals; + std::string catName; + std::map tblParams; + + _FireEventRequest__isset __isset; + + void __set_successful(const bool val); + + void __set_data(const FireEventRequestData& val); + + void __set_dbName(const std::string& val); + + void __set_tableName(const std::string& val); + + void __set_partitionVals(const std::vector & val); + + void __set_catName(const std::string& val); + + void __set_tblParams(const std::map & val); + + bool operator == (const FireEventRequest & rhs) const; + bool operator != (const FireEventRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FireEventRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(FireEventRequest &a, FireEventRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const FireEventRequest& obj); + +typedef struct _FireEventResponse__isset { + _FireEventResponse__isset() : eventIds(false) {} + bool eventIds :1; +} _FireEventResponse__isset; + +class FireEventResponse : public virtual ::apache::thrift::TBase { + public: + + FireEventResponse(const FireEventResponse&); + FireEventResponse& operator=(const FireEventResponse&); + FireEventResponse() noexcept; + + virtual ~FireEventResponse() noexcept; + std::vector eventIds; + + _FireEventResponse__isset __isset; + + void __set_eventIds(const std::vector & val); + + bool operator == (const FireEventResponse & rhs) const; + bool operator != (const FireEventResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FireEventResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(FireEventResponse &a, FireEventResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const FireEventResponse& obj); + +typedef struct _WriteNotificationLogRequest__isset { + _WriteNotificationLogRequest__isset() : partitionVals(false) {} + bool partitionVals :1; +} _WriteNotificationLogRequest__isset; + +class WriteNotificationLogRequest : public virtual ::apache::thrift::TBase { + public: + + WriteNotificationLogRequest(const WriteNotificationLogRequest&); + WriteNotificationLogRequest& operator=(const WriteNotificationLogRequest&); + WriteNotificationLogRequest() noexcept; + + virtual ~WriteNotificationLogRequest() noexcept; + int64_t txnId; + int64_t writeId; + std::string db; + std::string table; + InsertEventRequestData fileInfo; + std::vector partitionVals; + + _WriteNotificationLogRequest__isset __isset; + + void __set_txnId(const int64_t val); + + void __set_writeId(const int64_t val); + + void __set_db(const std::string& val); + + void __set_table(const std::string& val); + + void __set_fileInfo(const InsertEventRequestData& val); + + void __set_partitionVals(const std::vector & val); + + bool operator == (const WriteNotificationLogRequest & rhs) const; + bool operator != (const WriteNotificationLogRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WriteNotificationLogRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WriteNotificationLogRequest &a, WriteNotificationLogRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WriteNotificationLogRequest& obj); + + +class WriteNotificationLogResponse : public virtual ::apache::thrift::TBase { + public: + + WriteNotificationLogResponse(const WriteNotificationLogResponse&) noexcept; + WriteNotificationLogResponse& operator=(const WriteNotificationLogResponse&) noexcept; + WriteNotificationLogResponse() noexcept; + + virtual ~WriteNotificationLogResponse() noexcept; + + bool operator == (const WriteNotificationLogResponse & /* rhs */) const; + bool operator != (const WriteNotificationLogResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WriteNotificationLogResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WriteNotificationLogResponse &a, WriteNotificationLogResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WriteNotificationLogResponse& obj); + + +class WriteNotificationLogBatchRequest : public virtual ::apache::thrift::TBase { + public: + + WriteNotificationLogBatchRequest(const WriteNotificationLogBatchRequest&); + WriteNotificationLogBatchRequest& operator=(const WriteNotificationLogBatchRequest&); + WriteNotificationLogBatchRequest() noexcept; + + virtual ~WriteNotificationLogBatchRequest() noexcept; + std::string catalog; + std::string db; + std::string table; + std::vector requestList; + + void __set_catalog(const std::string& val); + + void __set_db(const std::string& val); + + void __set_table(const std::string& val); + + void __set_requestList(const std::vector & val); + + bool operator == (const WriteNotificationLogBatchRequest & rhs) const; + bool operator != (const WriteNotificationLogBatchRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WriteNotificationLogBatchRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WriteNotificationLogBatchRequest &a, WriteNotificationLogBatchRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WriteNotificationLogBatchRequest& obj); + + +class WriteNotificationLogBatchResponse : public virtual ::apache::thrift::TBase { + public: + + WriteNotificationLogBatchResponse(const WriteNotificationLogBatchResponse&) noexcept; + WriteNotificationLogBatchResponse& operator=(const WriteNotificationLogBatchResponse&) noexcept; + WriteNotificationLogBatchResponse() noexcept; + + virtual ~WriteNotificationLogBatchResponse() noexcept; + + bool operator == (const WriteNotificationLogBatchResponse & /* rhs */) const; + bool operator != (const WriteNotificationLogBatchResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WriteNotificationLogBatchResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WriteNotificationLogBatchResponse &a, WriteNotificationLogBatchResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WriteNotificationLogBatchResponse& obj); + +typedef struct _MetadataPpdResult__isset { + _MetadataPpdResult__isset() : metadata(false), includeBitset(false) {} + bool metadata :1; + bool includeBitset :1; +} _MetadataPpdResult__isset; + +class MetadataPpdResult : public virtual ::apache::thrift::TBase { + public: + + MetadataPpdResult(const MetadataPpdResult&); + MetadataPpdResult& operator=(const MetadataPpdResult&); + MetadataPpdResult() noexcept; + + virtual ~MetadataPpdResult() noexcept; + std::string metadata; + std::string includeBitset; + + _MetadataPpdResult__isset __isset; + + void __set_metadata(const std::string& val); + + void __set_includeBitset(const std::string& val); + + bool operator == (const MetadataPpdResult & rhs) const; + bool operator != (const MetadataPpdResult &rhs) const { + return !(*this == rhs); + } + + bool operator < (const MetadataPpdResult & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(MetadataPpdResult &a, MetadataPpdResult &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const MetadataPpdResult& obj); + + +class GetFileMetadataByExprResult : public virtual ::apache::thrift::TBase { + public: + + GetFileMetadataByExprResult(const GetFileMetadataByExprResult&); + GetFileMetadataByExprResult& operator=(const GetFileMetadataByExprResult&); + GetFileMetadataByExprResult() noexcept; + + virtual ~GetFileMetadataByExprResult() noexcept; + std::map metadata; + bool isSupported; + + void __set_metadata(const std::map & val); + + void __set_isSupported(const bool val); + + bool operator == (const GetFileMetadataByExprResult & rhs) const; + bool operator != (const GetFileMetadataByExprResult &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetFileMetadataByExprResult & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetFileMetadataByExprResult &a, GetFileMetadataByExprResult &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetFileMetadataByExprResult& obj); + +typedef struct _GetFileMetadataByExprRequest__isset { + _GetFileMetadataByExprRequest__isset() : doGetFooters(false), type(false) {} + bool doGetFooters :1; + bool type :1; +} _GetFileMetadataByExprRequest__isset; + +class GetFileMetadataByExprRequest : public virtual ::apache::thrift::TBase { + public: + + GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest&); + GetFileMetadataByExprRequest& operator=(const GetFileMetadataByExprRequest&); + GetFileMetadataByExprRequest() noexcept; + + virtual ~GetFileMetadataByExprRequest() noexcept; + std::vector fileIds; + std::string expr; + bool doGetFooters; + /** + * + * @see FileMetadataExprType + */ + FileMetadataExprType::type type; + + _GetFileMetadataByExprRequest__isset __isset; + + void __set_fileIds(const std::vector & val); + + void __set_expr(const std::string& val); + + void __set_doGetFooters(const bool val); + + void __set_type(const FileMetadataExprType::type val); + + bool operator == (const GetFileMetadataByExprRequest & rhs) const; + bool operator != (const GetFileMetadataByExprRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetFileMetadataByExprRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetFileMetadataByExprRequest &a, GetFileMetadataByExprRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetFileMetadataByExprRequest& obj); + + +class GetFileMetadataResult : public virtual ::apache::thrift::TBase { + public: + + GetFileMetadataResult(const GetFileMetadataResult&); + GetFileMetadataResult& operator=(const GetFileMetadataResult&); + GetFileMetadataResult() noexcept; + + virtual ~GetFileMetadataResult() noexcept; + std::map metadata; + bool isSupported; + + void __set_metadata(const std::map & val); + + void __set_isSupported(const bool val); + + bool operator == (const GetFileMetadataResult & rhs) const; + bool operator != (const GetFileMetadataResult &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetFileMetadataResult & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetFileMetadataResult &a, GetFileMetadataResult &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetFileMetadataResult& obj); + + +class GetFileMetadataRequest : public virtual ::apache::thrift::TBase { + public: + + GetFileMetadataRequest(const GetFileMetadataRequest&); + GetFileMetadataRequest& operator=(const GetFileMetadataRequest&); + GetFileMetadataRequest() noexcept; + + virtual ~GetFileMetadataRequest() noexcept; + std::vector fileIds; + + void __set_fileIds(const std::vector & val); + + bool operator == (const GetFileMetadataRequest & rhs) const; + bool operator != (const GetFileMetadataRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetFileMetadataRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetFileMetadataRequest &a, GetFileMetadataRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetFileMetadataRequest& obj); + + +class PutFileMetadataResult : public virtual ::apache::thrift::TBase { + public: + + PutFileMetadataResult(const PutFileMetadataResult&) noexcept; + PutFileMetadataResult& operator=(const PutFileMetadataResult&) noexcept; + PutFileMetadataResult() noexcept; + + virtual ~PutFileMetadataResult() noexcept; + + bool operator == (const PutFileMetadataResult & /* rhs */) const; + bool operator != (const PutFileMetadataResult &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PutFileMetadataResult & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PutFileMetadataResult &a, PutFileMetadataResult &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PutFileMetadataResult& obj); + +typedef struct _PutFileMetadataRequest__isset { + _PutFileMetadataRequest__isset() : type(false) {} + bool type :1; +} _PutFileMetadataRequest__isset; + +class PutFileMetadataRequest : public virtual ::apache::thrift::TBase { + public: + + PutFileMetadataRequest(const PutFileMetadataRequest&); + PutFileMetadataRequest& operator=(const PutFileMetadataRequest&); + PutFileMetadataRequest() noexcept; + + virtual ~PutFileMetadataRequest() noexcept; + std::vector fileIds; + std::vector metadata; + /** + * + * @see FileMetadataExprType + */ + FileMetadataExprType::type type; + + _PutFileMetadataRequest__isset __isset; + + void __set_fileIds(const std::vector & val); + + void __set_metadata(const std::vector & val); + + void __set_type(const FileMetadataExprType::type val); + + bool operator == (const PutFileMetadataRequest & rhs) const; + bool operator != (const PutFileMetadataRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PutFileMetadataRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PutFileMetadataRequest &a, PutFileMetadataRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PutFileMetadataRequest& obj); + + +class ClearFileMetadataResult : public virtual ::apache::thrift::TBase { + public: + + ClearFileMetadataResult(const ClearFileMetadataResult&) noexcept; + ClearFileMetadataResult& operator=(const ClearFileMetadataResult&) noexcept; + ClearFileMetadataResult() noexcept; + + virtual ~ClearFileMetadataResult() noexcept; + + bool operator == (const ClearFileMetadataResult & /* rhs */) const; + bool operator != (const ClearFileMetadataResult &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ClearFileMetadataResult & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ClearFileMetadataResult &a, ClearFileMetadataResult &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ClearFileMetadataResult& obj); + + +class ClearFileMetadataRequest : public virtual ::apache::thrift::TBase { + public: + + ClearFileMetadataRequest(const ClearFileMetadataRequest&); + ClearFileMetadataRequest& operator=(const ClearFileMetadataRequest&); + ClearFileMetadataRequest() noexcept; + + virtual ~ClearFileMetadataRequest() noexcept; + std::vector fileIds; + + void __set_fileIds(const std::vector & val); + + bool operator == (const ClearFileMetadataRequest & rhs) const; + bool operator != (const ClearFileMetadataRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ClearFileMetadataRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ClearFileMetadataRequest &a, ClearFileMetadataRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ClearFileMetadataRequest& obj); + + +class CacheFileMetadataResult : public virtual ::apache::thrift::TBase { + public: + + CacheFileMetadataResult(const CacheFileMetadataResult&) noexcept; + CacheFileMetadataResult& operator=(const CacheFileMetadataResult&) noexcept; + CacheFileMetadataResult() noexcept; + + virtual ~CacheFileMetadataResult() noexcept; + bool isSupported; + + void __set_isSupported(const bool val); + + bool operator == (const CacheFileMetadataResult & rhs) const; + bool operator != (const CacheFileMetadataResult &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CacheFileMetadataResult & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(CacheFileMetadataResult &a, CacheFileMetadataResult &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const CacheFileMetadataResult& obj); + +typedef struct _CacheFileMetadataRequest__isset { + _CacheFileMetadataRequest__isset() : partName(false), isAllParts(false) {} + bool partName :1; + bool isAllParts :1; +} _CacheFileMetadataRequest__isset; + +class CacheFileMetadataRequest : public virtual ::apache::thrift::TBase { + public: + + CacheFileMetadataRequest(const CacheFileMetadataRequest&); + CacheFileMetadataRequest& operator=(const CacheFileMetadataRequest&); + CacheFileMetadataRequest() noexcept; + + virtual ~CacheFileMetadataRequest() noexcept; + std::string dbName; + std::string tblName; + std::string partName; + bool isAllParts; + + _CacheFileMetadataRequest__isset __isset; + + void __set_dbName(const std::string& val); + + void __set_tblName(const std::string& val); + + void __set_partName(const std::string& val); + + void __set_isAllParts(const bool val); + + bool operator == (const CacheFileMetadataRequest & rhs) const; + bool operator != (const CacheFileMetadataRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CacheFileMetadataRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(CacheFileMetadataRequest &a, CacheFileMetadataRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const CacheFileMetadataRequest& obj); + +typedef struct _GetAllFunctionsResponse__isset { + _GetAllFunctionsResponse__isset() : functions(false) {} + bool functions :1; +} _GetAllFunctionsResponse__isset; + +class GetAllFunctionsResponse : public virtual ::apache::thrift::TBase { + public: + + GetAllFunctionsResponse(const GetAllFunctionsResponse&); + GetAllFunctionsResponse& operator=(const GetAllFunctionsResponse&); + GetAllFunctionsResponse() noexcept; + + virtual ~GetAllFunctionsResponse() noexcept; + std::vector functions; + + _GetAllFunctionsResponse__isset __isset; + + void __set_functions(const std::vector & val); + + bool operator == (const GetAllFunctionsResponse & rhs) const; + bool operator != (const GetAllFunctionsResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetAllFunctionsResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetAllFunctionsResponse& obj); + + +class ClientCapabilities : public virtual ::apache::thrift::TBase { + public: + + ClientCapabilities(const ClientCapabilities&); + ClientCapabilities& operator=(const ClientCapabilities&); + ClientCapabilities() noexcept; + + virtual ~ClientCapabilities() noexcept; + std::vector values; + + void __set_values(const std::vector & val); + + bool operator == (const ClientCapabilities & rhs) const; + bool operator != (const ClientCapabilities &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ClientCapabilities & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ClientCapabilities &a, ClientCapabilities &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ClientCapabilities& obj); + +typedef struct _GetProjectionsSpec__isset { + _GetProjectionsSpec__isset() : fieldList(false), includeParamKeyPattern(false), excludeParamKeyPattern(false) {} + bool fieldList :1; + bool includeParamKeyPattern :1; + bool excludeParamKeyPattern :1; +} _GetProjectionsSpec__isset; + +class GetProjectionsSpec : public virtual ::apache::thrift::TBase { + public: + + GetProjectionsSpec(const GetProjectionsSpec&); + GetProjectionsSpec& operator=(const GetProjectionsSpec&); + GetProjectionsSpec() noexcept; + + virtual ~GetProjectionsSpec() noexcept; + std::vector fieldList; + std::string includeParamKeyPattern; + std::string excludeParamKeyPattern; + + _GetProjectionsSpec__isset __isset; + + void __set_fieldList(const std::vector & val); + + void __set_includeParamKeyPattern(const std::string& val); + + void __set_excludeParamKeyPattern(const std::string& val); + + bool operator == (const GetProjectionsSpec & rhs) const; + bool operator != (const GetProjectionsSpec &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetProjectionsSpec & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetProjectionsSpec &a, GetProjectionsSpec &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetProjectionsSpec& obj); + +typedef struct _GetTableRequest__isset { + _GetTableRequest__isset() : capabilities(false), catName(false), validWriteIdList(false), getColumnStats(false), processorCapabilities(false), processorIdentifier(false), engine(true), id(true) {} + bool capabilities :1; + bool catName :1; + bool validWriteIdList :1; + bool getColumnStats :1; + bool processorCapabilities :1; + bool processorIdentifier :1; + bool engine :1; + bool id :1; +} _GetTableRequest__isset; + +class GetTableRequest : public virtual ::apache::thrift::TBase { + public: + + GetTableRequest(const GetTableRequest&); + GetTableRequest& operator=(const GetTableRequest&); + GetTableRequest(); + + virtual ~GetTableRequest() noexcept; + std::string dbName; + std::string tblName; + ClientCapabilities capabilities; + std::string catName; + std::string validWriteIdList; + bool getColumnStats; + std::vector processorCapabilities; + std::string processorIdentifier; + std::string engine; + int64_t id; + + _GetTableRequest__isset __isset; + + void __set_dbName(const std::string& val); + + void __set_tblName(const std::string& val); + + void __set_capabilities(const ClientCapabilities& val); + + void __set_catName(const std::string& val); + + void __set_validWriteIdList(const std::string& val); + + void __set_getColumnStats(const bool val); + + void __set_processorCapabilities(const std::vector & val); + + void __set_processorIdentifier(const std::string& val); + + void __set_engine(const std::string& val); + + void __set_id(const int64_t val); + + bool operator == (const GetTableRequest & rhs) const; + bool operator != (const GetTableRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetTableRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetTableRequest &a, GetTableRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetTableRequest& obj); + +typedef struct _GetTableResult__isset { + _GetTableResult__isset() : isStatsCompliant(false) {} + bool isStatsCompliant :1; +} _GetTableResult__isset; + +class GetTableResult : public virtual ::apache::thrift::TBase { + public: + + GetTableResult(const GetTableResult&); + GetTableResult& operator=(const GetTableResult&); + GetTableResult() noexcept; + + virtual ~GetTableResult() noexcept; + Table table; + bool isStatsCompliant; + + _GetTableResult__isset __isset; + + void __set_table(const Table& val); + + void __set_isStatsCompliant(const bool val); + + bool operator == (const GetTableResult & rhs) const; + bool operator != (const GetTableResult &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetTableResult & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetTableResult &a, GetTableResult &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetTableResult& obj); + +typedef struct _GetTablesRequest__isset { + _GetTablesRequest__isset() : tblNames(false), capabilities(false), catName(false), processorCapabilities(false), processorIdentifier(false), projectionSpec(false), tablesPattern(false) {} + bool tblNames :1; + bool capabilities :1; + bool catName :1; + bool processorCapabilities :1; + bool processorIdentifier :1; + bool projectionSpec :1; + bool tablesPattern :1; +} _GetTablesRequest__isset; + +class GetTablesRequest : public virtual ::apache::thrift::TBase { + public: + + GetTablesRequest(const GetTablesRequest&); + GetTablesRequest& operator=(const GetTablesRequest&); + GetTablesRequest() noexcept; + + virtual ~GetTablesRequest() noexcept; + std::string dbName; + std::vector tblNames; + ClientCapabilities capabilities; + std::string catName; + std::vector processorCapabilities; + std::string processorIdentifier; + GetProjectionsSpec projectionSpec; + std::string tablesPattern; + + _GetTablesRequest__isset __isset; + + void __set_dbName(const std::string& val); + + void __set_tblNames(const std::vector & val); + + void __set_capabilities(const ClientCapabilities& val); + + void __set_catName(const std::string& val); + + void __set_processorCapabilities(const std::vector & val); + + void __set_processorIdentifier(const std::string& val); + + void __set_projectionSpec(const GetProjectionsSpec& val); + + void __set_tablesPattern(const std::string& val); + + bool operator == (const GetTablesRequest & rhs) const; + bool operator != (const GetTablesRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetTablesRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetTablesRequest &a, GetTablesRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetTablesRequest& obj); + + +class GetTablesResult : public virtual ::apache::thrift::TBase { + public: + + GetTablesResult(const GetTablesResult&); + GetTablesResult& operator=(const GetTablesResult&); + GetTablesResult() noexcept; + + virtual ~GetTablesResult() noexcept; + std::vector
tables; + + void __set_tables(const std::vector
& val); + + bool operator == (const GetTablesResult & rhs) const; + bool operator != (const GetTablesResult &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetTablesResult & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetTablesResult &a, GetTablesResult &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetTablesResult& obj); + +typedef struct _GetTablesExtRequest__isset { + _GetTablesExtRequest__isset() : limit(false), processorCapabilities(false), processorIdentifier(false) {} + bool limit :1; + bool processorCapabilities :1; + bool processorIdentifier :1; +} _GetTablesExtRequest__isset; + +class GetTablesExtRequest : public virtual ::apache::thrift::TBase { + public: + + GetTablesExtRequest(const GetTablesExtRequest&); + GetTablesExtRequest& operator=(const GetTablesExtRequest&); + GetTablesExtRequest() noexcept; + + virtual ~GetTablesExtRequest() noexcept; + std::string catalog; + std::string database; + std::string tableNamePattern; + int32_t requestedFields; + int32_t limit; + std::vector processorCapabilities; + std::string processorIdentifier; + + _GetTablesExtRequest__isset __isset; + + void __set_catalog(const std::string& val); + + void __set_database(const std::string& val); + + void __set_tableNamePattern(const std::string& val); + + void __set_requestedFields(const int32_t val); + + void __set_limit(const int32_t val); + + void __set_processorCapabilities(const std::vector & val); + + void __set_processorIdentifier(const std::string& val); + + bool operator == (const GetTablesExtRequest & rhs) const; + bool operator != (const GetTablesExtRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetTablesExtRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetTablesExtRequest &a, GetTablesExtRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetTablesExtRequest& obj); + +typedef struct _ExtendedTableInfo__isset { + _ExtendedTableInfo__isset() : accessType(false), requiredReadCapabilities(false), requiredWriteCapabilities(false) {} + bool accessType :1; + bool requiredReadCapabilities :1; + bool requiredWriteCapabilities :1; +} _ExtendedTableInfo__isset; + +class ExtendedTableInfo : public virtual ::apache::thrift::TBase { + public: + + ExtendedTableInfo(const ExtendedTableInfo&); + ExtendedTableInfo& operator=(const ExtendedTableInfo&); + ExtendedTableInfo() noexcept; + + virtual ~ExtendedTableInfo() noexcept; + std::string tblName; + int32_t accessType; + std::vector requiredReadCapabilities; + std::vector requiredWriteCapabilities; + + _ExtendedTableInfo__isset __isset; + + void __set_tblName(const std::string& val); + + void __set_accessType(const int32_t val); + + void __set_requiredReadCapabilities(const std::vector & val); + + void __set_requiredWriteCapabilities(const std::vector & val); + + bool operator == (const ExtendedTableInfo & rhs) const; + bool operator != (const ExtendedTableInfo &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ExtendedTableInfo & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ExtendedTableInfo &a, ExtendedTableInfo &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ExtendedTableInfo& obj); + +typedef struct _DropTableRequest__isset { + _DropTableRequest__isset() : catalogName(false), deleteData(false), envContext(false), dropPartitions(false) {} + bool catalogName :1; + bool deleteData :1; + bool envContext :1; + bool dropPartitions :1; +} _DropTableRequest__isset; + +class DropTableRequest : public virtual ::apache::thrift::TBase { + public: + + DropTableRequest(const DropTableRequest&); + DropTableRequest& operator=(const DropTableRequest&); + DropTableRequest() noexcept; + + virtual ~DropTableRequest() noexcept; + std::string catalogName; + std::string dbName; + std::string tableName; + bool deleteData; + EnvironmentContext envContext; + bool dropPartitions; + + _DropTableRequest__isset __isset; + + void __set_catalogName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_tableName(const std::string& val); + + void __set_deleteData(const bool val); + + void __set_envContext(const EnvironmentContext& val); + + void __set_dropPartitions(const bool val); + + bool operator == (const DropTableRequest & rhs) const; + bool operator != (const DropTableRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const DropTableRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(DropTableRequest &a, DropTableRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const DropTableRequest& obj); + +typedef struct _GetDatabaseRequest__isset { + _GetDatabaseRequest__isset() : name(false), catalogName(false), processorCapabilities(false), processorIdentifier(false) {} + bool name :1; + bool catalogName :1; + bool processorCapabilities :1; + bool processorIdentifier :1; +} _GetDatabaseRequest__isset; + +class GetDatabaseRequest : public virtual ::apache::thrift::TBase { + public: + + GetDatabaseRequest(const GetDatabaseRequest&); + GetDatabaseRequest& operator=(const GetDatabaseRequest&); + GetDatabaseRequest() noexcept; + + virtual ~GetDatabaseRequest() noexcept; + std::string name; + std::string catalogName; + std::vector processorCapabilities; + std::string processorIdentifier; + + _GetDatabaseRequest__isset __isset; + + void __set_name(const std::string& val); + + void __set_catalogName(const std::string& val); + + void __set_processorCapabilities(const std::vector & val); + + void __set_processorIdentifier(const std::string& val); + + bool operator == (const GetDatabaseRequest & rhs) const; + bool operator != (const GetDatabaseRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetDatabaseRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetDatabaseRequest &a, GetDatabaseRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetDatabaseRequest& obj); + + +class AlterDatabaseRequest : public virtual ::apache::thrift::TBase { + public: + + AlterDatabaseRequest(const AlterDatabaseRequest&); + AlterDatabaseRequest& operator=(const AlterDatabaseRequest&); + AlterDatabaseRequest() noexcept; + + virtual ~AlterDatabaseRequest() noexcept; + std::string oldDbName; + Database newDb; + + void __set_oldDbName(const std::string& val); + + void __set_newDb(const Database& val); + + bool operator == (const AlterDatabaseRequest & rhs) const; + bool operator != (const AlterDatabaseRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AlterDatabaseRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AlterDatabaseRequest &a, AlterDatabaseRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AlterDatabaseRequest& obj); + +typedef struct _DropDatabaseRequest__isset { + _DropDatabaseRequest__isset() : catalogName(false), softDelete(true), txnId(true), deleteManagedDir(true) {} + bool catalogName :1; + bool softDelete :1; + bool txnId :1; + bool deleteManagedDir :1; +} _DropDatabaseRequest__isset; + +class DropDatabaseRequest : public virtual ::apache::thrift::TBase { + public: + + DropDatabaseRequest(const DropDatabaseRequest&); + DropDatabaseRequest& operator=(const DropDatabaseRequest&); + DropDatabaseRequest() noexcept; + + virtual ~DropDatabaseRequest() noexcept; + std::string name; + std::string catalogName; + bool ignoreUnknownDb; + bool deleteData; + bool cascade; + bool softDelete; + int64_t txnId; + bool deleteManagedDir; + + _DropDatabaseRequest__isset __isset; + + void __set_name(const std::string& val); + + void __set_catalogName(const std::string& val); + + void __set_ignoreUnknownDb(const bool val); + + void __set_deleteData(const bool val); + + void __set_cascade(const bool val); + + void __set_softDelete(const bool val); + + void __set_txnId(const int64_t val); + + void __set_deleteManagedDir(const bool val); + + bool operator == (const DropDatabaseRequest & rhs) const; + bool operator != (const DropDatabaseRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const DropDatabaseRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(DropDatabaseRequest &a, DropDatabaseRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const DropDatabaseRequest& obj); + + +class CmRecycleRequest : public virtual ::apache::thrift::TBase { + public: + + CmRecycleRequest(const CmRecycleRequest&); + CmRecycleRequest& operator=(const CmRecycleRequest&); + CmRecycleRequest() noexcept; + + virtual ~CmRecycleRequest() noexcept; + std::string dataPath; + bool purge; + + void __set_dataPath(const std::string& val); + + void __set_purge(const bool val); + + bool operator == (const CmRecycleRequest & rhs) const; + bool operator != (const CmRecycleRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CmRecycleRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(CmRecycleRequest &a, CmRecycleRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const CmRecycleRequest& obj); + + +class CmRecycleResponse : public virtual ::apache::thrift::TBase { + public: + + CmRecycleResponse(const CmRecycleResponse&) noexcept; + CmRecycleResponse& operator=(const CmRecycleResponse&) noexcept; + CmRecycleResponse() noexcept; + + virtual ~CmRecycleResponse() noexcept; + + bool operator == (const CmRecycleResponse & /* rhs */) const; + bool operator != (const CmRecycleResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CmRecycleResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(CmRecycleResponse &a, CmRecycleResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const CmRecycleResponse& obj); + +typedef struct _TableMeta__isset { + _TableMeta__isset() : comments(false), catName(false), ownerName(false), ownerType(false) {} + bool comments :1; + bool catName :1; + bool ownerName :1; + bool ownerType :1; +} _TableMeta__isset; + +class TableMeta : public virtual ::apache::thrift::TBase { + public: + + TableMeta(const TableMeta&); + TableMeta& operator=(const TableMeta&); + TableMeta() noexcept; + + virtual ~TableMeta() noexcept; + std::string dbName; + std::string tableName; + std::string tableType; + std::string comments; + std::string catName; + std::string ownerName; + /** + * + * @see PrincipalType + */ + PrincipalType::type ownerType; + + _TableMeta__isset __isset; + + void __set_dbName(const std::string& val); + + void __set_tableName(const std::string& val); + + void __set_tableType(const std::string& val); + + void __set_comments(const std::string& val); + + void __set_catName(const std::string& val); + + void __set_ownerName(const std::string& val); + + void __set_ownerType(const PrincipalType::type val); + + bool operator == (const TableMeta & rhs) const; + bool operator != (const TableMeta &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TableMeta & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TableMeta &a, TableMeta &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const TableMeta& obj); + + +class Materialization : public virtual ::apache::thrift::TBase { + public: + + Materialization(const Materialization&) noexcept; + Materialization& operator=(const Materialization&) noexcept; + Materialization() noexcept; + + virtual ~Materialization() noexcept; + bool sourceTablesUpdateDeleteModified; + bool sourceTablesCompacted; + + void __set_sourceTablesUpdateDeleteModified(const bool val); + + void __set_sourceTablesCompacted(const bool val); + + bool operator == (const Materialization & rhs) const; + bool operator != (const Materialization &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Materialization & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Materialization &a, Materialization &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const Materialization& obj); + +typedef struct _WMResourcePlan__isset { + _WMResourcePlan__isset() : status(false), queryParallelism(false), defaultPoolPath(false), ns(false) {} + bool status :1; + bool queryParallelism :1; + bool defaultPoolPath :1; + bool ns :1; +} _WMResourcePlan__isset; + +class WMResourcePlan : public virtual ::apache::thrift::TBase { + public: + + WMResourcePlan(const WMResourcePlan&); + WMResourcePlan& operator=(const WMResourcePlan&); + WMResourcePlan() noexcept; + + virtual ~WMResourcePlan() noexcept; + std::string name; + /** + * + * @see WMResourcePlanStatus + */ + WMResourcePlanStatus::type status; + int32_t queryParallelism; + std::string defaultPoolPath; + std::string ns; + + _WMResourcePlan__isset __isset; + + void __set_name(const std::string& val); + + void __set_status(const WMResourcePlanStatus::type val); + + void __set_queryParallelism(const int32_t val); + + void __set_defaultPoolPath(const std::string& val); + + void __set_ns(const std::string& val); + + bool operator == (const WMResourcePlan & rhs) const; + bool operator != (const WMResourcePlan &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMResourcePlan & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMResourcePlan &a, WMResourcePlan &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMResourcePlan& obj); + +typedef struct _WMNullableResourcePlan__isset { + _WMNullableResourcePlan__isset() : name(false), status(false), queryParallelism(false), isSetQueryParallelism(false), defaultPoolPath(false), isSetDefaultPoolPath(false), ns(false) {} + bool name :1; + bool status :1; + bool queryParallelism :1; + bool isSetQueryParallelism :1; + bool defaultPoolPath :1; + bool isSetDefaultPoolPath :1; + bool ns :1; +} _WMNullableResourcePlan__isset; + +class WMNullableResourcePlan : public virtual ::apache::thrift::TBase { + public: + + WMNullableResourcePlan(const WMNullableResourcePlan&); + WMNullableResourcePlan& operator=(const WMNullableResourcePlan&); + WMNullableResourcePlan() noexcept; + + virtual ~WMNullableResourcePlan() noexcept; + std::string name; + /** + * + * @see WMResourcePlanStatus + */ + WMResourcePlanStatus::type status; + int32_t queryParallelism; + bool isSetQueryParallelism; + std::string defaultPoolPath; + bool isSetDefaultPoolPath; + std::string ns; + + _WMNullableResourcePlan__isset __isset; + + void __set_name(const std::string& val); + + void __set_status(const WMResourcePlanStatus::type val); + + void __set_queryParallelism(const int32_t val); + + void __set_isSetQueryParallelism(const bool val); + + void __set_defaultPoolPath(const std::string& val); + + void __set_isSetDefaultPoolPath(const bool val); + + void __set_ns(const std::string& val); + + bool operator == (const WMNullableResourcePlan & rhs) const; + bool operator != (const WMNullableResourcePlan &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMNullableResourcePlan & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMNullableResourcePlan &a, WMNullableResourcePlan &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMNullableResourcePlan& obj); + +typedef struct _WMPool__isset { + _WMPool__isset() : allocFraction(false), queryParallelism(false), schedulingPolicy(false), ns(false) {} + bool allocFraction :1; + bool queryParallelism :1; + bool schedulingPolicy :1; + bool ns :1; +} _WMPool__isset; + +class WMPool : public virtual ::apache::thrift::TBase { + public: + + WMPool(const WMPool&); + WMPool& operator=(const WMPool&); + WMPool() noexcept; + + virtual ~WMPool() noexcept; + std::string resourcePlanName; + std::string poolPath; + double allocFraction; + int32_t queryParallelism; + std::string schedulingPolicy; + std::string ns; + + _WMPool__isset __isset; + + void __set_resourcePlanName(const std::string& val); + + void __set_poolPath(const std::string& val); + + void __set_allocFraction(const double val); + + void __set_queryParallelism(const int32_t val); + + void __set_schedulingPolicy(const std::string& val); + + void __set_ns(const std::string& val); + + bool operator == (const WMPool & rhs) const; + bool operator != (const WMPool &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMPool & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMPool &a, WMPool &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMPool& obj); + +typedef struct _WMNullablePool__isset { + _WMNullablePool__isset() : allocFraction(false), queryParallelism(false), schedulingPolicy(false), isSetSchedulingPolicy(false), ns(false) {} + bool allocFraction :1; + bool queryParallelism :1; + bool schedulingPolicy :1; + bool isSetSchedulingPolicy :1; + bool ns :1; +} _WMNullablePool__isset; + +class WMNullablePool : public virtual ::apache::thrift::TBase { + public: + + WMNullablePool(const WMNullablePool&); + WMNullablePool& operator=(const WMNullablePool&); + WMNullablePool() noexcept; + + virtual ~WMNullablePool() noexcept; + std::string resourcePlanName; + std::string poolPath; + double allocFraction; + int32_t queryParallelism; + std::string schedulingPolicy; + bool isSetSchedulingPolicy; + std::string ns; + + _WMNullablePool__isset __isset; + + void __set_resourcePlanName(const std::string& val); + + void __set_poolPath(const std::string& val); + + void __set_allocFraction(const double val); + + void __set_queryParallelism(const int32_t val); + + void __set_schedulingPolicy(const std::string& val); + + void __set_isSetSchedulingPolicy(const bool val); + + void __set_ns(const std::string& val); + + bool operator == (const WMNullablePool & rhs) const; + bool operator != (const WMNullablePool &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMNullablePool & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMNullablePool &a, WMNullablePool &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMNullablePool& obj); + +typedef struct _WMTrigger__isset { + _WMTrigger__isset() : triggerExpression(false), actionExpression(false), isInUnmanaged(false), ns(false) {} + bool triggerExpression :1; + bool actionExpression :1; + bool isInUnmanaged :1; + bool ns :1; +} _WMTrigger__isset; + +class WMTrigger : public virtual ::apache::thrift::TBase { + public: + + WMTrigger(const WMTrigger&); + WMTrigger& operator=(const WMTrigger&); + WMTrigger() noexcept; + + virtual ~WMTrigger() noexcept; + std::string resourcePlanName; + std::string triggerName; + std::string triggerExpression; + std::string actionExpression; + bool isInUnmanaged; + std::string ns; + + _WMTrigger__isset __isset; + + void __set_resourcePlanName(const std::string& val); + + void __set_triggerName(const std::string& val); + + void __set_triggerExpression(const std::string& val); + + void __set_actionExpression(const std::string& val); + + void __set_isInUnmanaged(const bool val); + + void __set_ns(const std::string& val); + + bool operator == (const WMTrigger & rhs) const; + bool operator != (const WMTrigger &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMTrigger & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMTrigger &a, WMTrigger &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMTrigger& obj); + +typedef struct _WMMapping__isset { + _WMMapping__isset() : poolPath(false), ordering(false), ns(false) {} + bool poolPath :1; + bool ordering :1; + bool ns :1; +} _WMMapping__isset; + +class WMMapping : public virtual ::apache::thrift::TBase { + public: + + WMMapping(const WMMapping&); + WMMapping& operator=(const WMMapping&); + WMMapping() noexcept; + + virtual ~WMMapping() noexcept; + std::string resourcePlanName; + std::string entityType; + std::string entityName; + std::string poolPath; + int32_t ordering; + std::string ns; + + _WMMapping__isset __isset; + + void __set_resourcePlanName(const std::string& val); + + void __set_entityType(const std::string& val); + + void __set_entityName(const std::string& val); + + void __set_poolPath(const std::string& val); + + void __set_ordering(const int32_t val); + + void __set_ns(const std::string& val); + + bool operator == (const WMMapping & rhs) const; + bool operator != (const WMMapping &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMMapping & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMMapping &a, WMMapping &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMMapping& obj); + +typedef struct _WMPoolTrigger__isset { + _WMPoolTrigger__isset() : ns(false) {} + bool ns :1; +} _WMPoolTrigger__isset; + +class WMPoolTrigger : public virtual ::apache::thrift::TBase { + public: + + WMPoolTrigger(const WMPoolTrigger&); + WMPoolTrigger& operator=(const WMPoolTrigger&); + WMPoolTrigger() noexcept; + + virtual ~WMPoolTrigger() noexcept; + std::string pool; + std::string trigger; + std::string ns; + + _WMPoolTrigger__isset __isset; + + void __set_pool(const std::string& val); + + void __set_trigger(const std::string& val); + + void __set_ns(const std::string& val); + + bool operator == (const WMPoolTrigger & rhs) const; + bool operator != (const WMPoolTrigger &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMPoolTrigger & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMPoolTrigger &a, WMPoolTrigger &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMPoolTrigger& obj); + +typedef struct _WMFullResourcePlan__isset { + _WMFullResourcePlan__isset() : mappings(false), triggers(false), poolTriggers(false) {} + bool mappings :1; + bool triggers :1; + bool poolTriggers :1; +} _WMFullResourcePlan__isset; + +class WMFullResourcePlan : public virtual ::apache::thrift::TBase { + public: + + WMFullResourcePlan(const WMFullResourcePlan&); + WMFullResourcePlan& operator=(const WMFullResourcePlan&); + WMFullResourcePlan() noexcept; + + virtual ~WMFullResourcePlan() noexcept; + WMResourcePlan plan; + std::vector pools; + std::vector mappings; + std::vector triggers; + std::vector poolTriggers; + + _WMFullResourcePlan__isset __isset; + + void __set_plan(const WMResourcePlan& val); + + void __set_pools(const std::vector & val); + + void __set_mappings(const std::vector & val); + + void __set_triggers(const std::vector & val); + + void __set_poolTriggers(const std::vector & val); + + bool operator == (const WMFullResourcePlan & rhs) const; + bool operator != (const WMFullResourcePlan &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMFullResourcePlan & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMFullResourcePlan &a, WMFullResourcePlan &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMFullResourcePlan& obj); + +typedef struct _WMCreateResourcePlanRequest__isset { + _WMCreateResourcePlanRequest__isset() : resourcePlan(false), copyFrom(false) {} + bool resourcePlan :1; + bool copyFrom :1; +} _WMCreateResourcePlanRequest__isset; + +class WMCreateResourcePlanRequest : public virtual ::apache::thrift::TBase { + public: + + WMCreateResourcePlanRequest(const WMCreateResourcePlanRequest&); + WMCreateResourcePlanRequest& operator=(const WMCreateResourcePlanRequest&); + WMCreateResourcePlanRequest() noexcept; + + virtual ~WMCreateResourcePlanRequest() noexcept; + WMResourcePlan resourcePlan; + std::string copyFrom; + + _WMCreateResourcePlanRequest__isset __isset; + + void __set_resourcePlan(const WMResourcePlan& val); + + void __set_copyFrom(const std::string& val); + + bool operator == (const WMCreateResourcePlanRequest & rhs) const; + bool operator != (const WMCreateResourcePlanRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMCreateResourcePlanRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMCreateResourcePlanRequest &a, WMCreateResourcePlanRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMCreateResourcePlanRequest& obj); + + +class WMCreateResourcePlanResponse : public virtual ::apache::thrift::TBase { + public: + + WMCreateResourcePlanResponse(const WMCreateResourcePlanResponse&) noexcept; + WMCreateResourcePlanResponse& operator=(const WMCreateResourcePlanResponse&) noexcept; + WMCreateResourcePlanResponse() noexcept; + + virtual ~WMCreateResourcePlanResponse() noexcept; + + bool operator == (const WMCreateResourcePlanResponse & /* rhs */) const; + bool operator != (const WMCreateResourcePlanResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMCreateResourcePlanResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMCreateResourcePlanResponse &a, WMCreateResourcePlanResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMCreateResourcePlanResponse& obj); + +typedef struct _WMGetActiveResourcePlanRequest__isset { + _WMGetActiveResourcePlanRequest__isset() : ns(false) {} + bool ns :1; +} _WMGetActiveResourcePlanRequest__isset; + +class WMGetActiveResourcePlanRequest : public virtual ::apache::thrift::TBase { + public: + + WMGetActiveResourcePlanRequest(const WMGetActiveResourcePlanRequest&); + WMGetActiveResourcePlanRequest& operator=(const WMGetActiveResourcePlanRequest&); + WMGetActiveResourcePlanRequest() noexcept; + + virtual ~WMGetActiveResourcePlanRequest() noexcept; + std::string ns; + + _WMGetActiveResourcePlanRequest__isset __isset; + + void __set_ns(const std::string& val); + + bool operator == (const WMGetActiveResourcePlanRequest & rhs) const; + bool operator != (const WMGetActiveResourcePlanRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMGetActiveResourcePlanRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMGetActiveResourcePlanRequest &a, WMGetActiveResourcePlanRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMGetActiveResourcePlanRequest& obj); + +typedef struct _WMGetActiveResourcePlanResponse__isset { + _WMGetActiveResourcePlanResponse__isset() : resourcePlan(false) {} + bool resourcePlan :1; +} _WMGetActiveResourcePlanResponse__isset; + +class WMGetActiveResourcePlanResponse : public virtual ::apache::thrift::TBase { + public: + + WMGetActiveResourcePlanResponse(const WMGetActiveResourcePlanResponse&); + WMGetActiveResourcePlanResponse& operator=(const WMGetActiveResourcePlanResponse&); + WMGetActiveResourcePlanResponse() noexcept; + + virtual ~WMGetActiveResourcePlanResponse() noexcept; + WMFullResourcePlan resourcePlan; + + _WMGetActiveResourcePlanResponse__isset __isset; + + void __set_resourcePlan(const WMFullResourcePlan& val); + + bool operator == (const WMGetActiveResourcePlanResponse & rhs) const; + bool operator != (const WMGetActiveResourcePlanResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMGetActiveResourcePlanResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMGetActiveResourcePlanResponse &a, WMGetActiveResourcePlanResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMGetActiveResourcePlanResponse& obj); + +typedef struct _WMGetResourcePlanRequest__isset { + _WMGetResourcePlanRequest__isset() : resourcePlanName(false), ns(false) {} + bool resourcePlanName :1; + bool ns :1; +} _WMGetResourcePlanRequest__isset; + +class WMGetResourcePlanRequest : public virtual ::apache::thrift::TBase { + public: + + WMGetResourcePlanRequest(const WMGetResourcePlanRequest&); + WMGetResourcePlanRequest& operator=(const WMGetResourcePlanRequest&); + WMGetResourcePlanRequest() noexcept; + + virtual ~WMGetResourcePlanRequest() noexcept; + std::string resourcePlanName; + std::string ns; + + _WMGetResourcePlanRequest__isset __isset; + + void __set_resourcePlanName(const std::string& val); + + void __set_ns(const std::string& val); + + bool operator == (const WMGetResourcePlanRequest & rhs) const; + bool operator != (const WMGetResourcePlanRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMGetResourcePlanRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMGetResourcePlanRequest &a, WMGetResourcePlanRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMGetResourcePlanRequest& obj); + +typedef struct _WMGetResourcePlanResponse__isset { + _WMGetResourcePlanResponse__isset() : resourcePlan(false) {} + bool resourcePlan :1; +} _WMGetResourcePlanResponse__isset; + +class WMGetResourcePlanResponse : public virtual ::apache::thrift::TBase { + public: + + WMGetResourcePlanResponse(const WMGetResourcePlanResponse&); + WMGetResourcePlanResponse& operator=(const WMGetResourcePlanResponse&); + WMGetResourcePlanResponse() noexcept; + + virtual ~WMGetResourcePlanResponse() noexcept; + WMFullResourcePlan resourcePlan; + + _WMGetResourcePlanResponse__isset __isset; + + void __set_resourcePlan(const WMFullResourcePlan& val); + + bool operator == (const WMGetResourcePlanResponse & rhs) const; + bool operator != (const WMGetResourcePlanResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMGetResourcePlanResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMGetResourcePlanResponse &a, WMGetResourcePlanResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMGetResourcePlanResponse& obj); + +typedef struct _WMGetAllResourcePlanRequest__isset { + _WMGetAllResourcePlanRequest__isset() : ns(false) {} + bool ns :1; +} _WMGetAllResourcePlanRequest__isset; + +class WMGetAllResourcePlanRequest : public virtual ::apache::thrift::TBase { + public: + + WMGetAllResourcePlanRequest(const WMGetAllResourcePlanRequest&); + WMGetAllResourcePlanRequest& operator=(const WMGetAllResourcePlanRequest&); + WMGetAllResourcePlanRequest() noexcept; + + virtual ~WMGetAllResourcePlanRequest() noexcept; + std::string ns; + + _WMGetAllResourcePlanRequest__isset __isset; + + void __set_ns(const std::string& val); + + bool operator == (const WMGetAllResourcePlanRequest & rhs) const; + bool operator != (const WMGetAllResourcePlanRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMGetAllResourcePlanRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMGetAllResourcePlanRequest &a, WMGetAllResourcePlanRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMGetAllResourcePlanRequest& obj); + +typedef struct _WMGetAllResourcePlanResponse__isset { + _WMGetAllResourcePlanResponse__isset() : resourcePlans(false) {} + bool resourcePlans :1; +} _WMGetAllResourcePlanResponse__isset; + +class WMGetAllResourcePlanResponse : public virtual ::apache::thrift::TBase { + public: + + WMGetAllResourcePlanResponse(const WMGetAllResourcePlanResponse&); + WMGetAllResourcePlanResponse& operator=(const WMGetAllResourcePlanResponse&); + WMGetAllResourcePlanResponse() noexcept; + + virtual ~WMGetAllResourcePlanResponse() noexcept; + std::vector resourcePlans; + + _WMGetAllResourcePlanResponse__isset __isset; + + void __set_resourcePlans(const std::vector & val); + + bool operator == (const WMGetAllResourcePlanResponse & rhs) const; + bool operator != (const WMGetAllResourcePlanResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMGetAllResourcePlanResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMGetAllResourcePlanResponse &a, WMGetAllResourcePlanResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMGetAllResourcePlanResponse& obj); + +typedef struct _WMAlterResourcePlanRequest__isset { + _WMAlterResourcePlanRequest__isset() : resourcePlanName(false), resourcePlan(false), isEnableAndActivate(false), isForceDeactivate(false), isReplace(false), ns(false) {} + bool resourcePlanName :1; + bool resourcePlan :1; + bool isEnableAndActivate :1; + bool isForceDeactivate :1; + bool isReplace :1; + bool ns :1; +} _WMAlterResourcePlanRequest__isset; + +class WMAlterResourcePlanRequest : public virtual ::apache::thrift::TBase { + public: + + WMAlterResourcePlanRequest(const WMAlterResourcePlanRequest&); + WMAlterResourcePlanRequest& operator=(const WMAlterResourcePlanRequest&); + WMAlterResourcePlanRequest() noexcept; + + virtual ~WMAlterResourcePlanRequest() noexcept; + std::string resourcePlanName; + WMNullableResourcePlan resourcePlan; + bool isEnableAndActivate; + bool isForceDeactivate; + bool isReplace; + std::string ns; + + _WMAlterResourcePlanRequest__isset __isset; + + void __set_resourcePlanName(const std::string& val); + + void __set_resourcePlan(const WMNullableResourcePlan& val); + + void __set_isEnableAndActivate(const bool val); + + void __set_isForceDeactivate(const bool val); + + void __set_isReplace(const bool val); + + void __set_ns(const std::string& val); + + bool operator == (const WMAlterResourcePlanRequest & rhs) const; + bool operator != (const WMAlterResourcePlanRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMAlterResourcePlanRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMAlterResourcePlanRequest &a, WMAlterResourcePlanRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMAlterResourcePlanRequest& obj); + +typedef struct _WMAlterResourcePlanResponse__isset { + _WMAlterResourcePlanResponse__isset() : fullResourcePlan(false) {} + bool fullResourcePlan :1; +} _WMAlterResourcePlanResponse__isset; + +class WMAlterResourcePlanResponse : public virtual ::apache::thrift::TBase { + public: + + WMAlterResourcePlanResponse(const WMAlterResourcePlanResponse&); + WMAlterResourcePlanResponse& operator=(const WMAlterResourcePlanResponse&); + WMAlterResourcePlanResponse() noexcept; + + virtual ~WMAlterResourcePlanResponse() noexcept; + WMFullResourcePlan fullResourcePlan; + + _WMAlterResourcePlanResponse__isset __isset; + + void __set_fullResourcePlan(const WMFullResourcePlan& val); + + bool operator == (const WMAlterResourcePlanResponse & rhs) const; + bool operator != (const WMAlterResourcePlanResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMAlterResourcePlanResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMAlterResourcePlanResponse &a, WMAlterResourcePlanResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMAlterResourcePlanResponse& obj); + +typedef struct _WMValidateResourcePlanRequest__isset { + _WMValidateResourcePlanRequest__isset() : resourcePlanName(false), ns(false) {} + bool resourcePlanName :1; + bool ns :1; +} _WMValidateResourcePlanRequest__isset; + +class WMValidateResourcePlanRequest : public virtual ::apache::thrift::TBase { + public: + + WMValidateResourcePlanRequest(const WMValidateResourcePlanRequest&); + WMValidateResourcePlanRequest& operator=(const WMValidateResourcePlanRequest&); + WMValidateResourcePlanRequest() noexcept; + + virtual ~WMValidateResourcePlanRequest() noexcept; + std::string resourcePlanName; + std::string ns; + + _WMValidateResourcePlanRequest__isset __isset; + + void __set_resourcePlanName(const std::string& val); + + void __set_ns(const std::string& val); + + bool operator == (const WMValidateResourcePlanRequest & rhs) const; + bool operator != (const WMValidateResourcePlanRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMValidateResourcePlanRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMValidateResourcePlanRequest &a, WMValidateResourcePlanRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMValidateResourcePlanRequest& obj); + +typedef struct _WMValidateResourcePlanResponse__isset { + _WMValidateResourcePlanResponse__isset() : errors(false), warnings(false) {} + bool errors :1; + bool warnings :1; +} _WMValidateResourcePlanResponse__isset; + +class WMValidateResourcePlanResponse : public virtual ::apache::thrift::TBase { + public: + + WMValidateResourcePlanResponse(const WMValidateResourcePlanResponse&); + WMValidateResourcePlanResponse& operator=(const WMValidateResourcePlanResponse&); + WMValidateResourcePlanResponse() noexcept; + + virtual ~WMValidateResourcePlanResponse() noexcept; + std::vector errors; + std::vector warnings; + + _WMValidateResourcePlanResponse__isset __isset; + + void __set_errors(const std::vector & val); + + void __set_warnings(const std::vector & val); + + bool operator == (const WMValidateResourcePlanResponse & rhs) const; + bool operator != (const WMValidateResourcePlanResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMValidateResourcePlanResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMValidateResourcePlanResponse &a, WMValidateResourcePlanResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMValidateResourcePlanResponse& obj); + +typedef struct _WMDropResourcePlanRequest__isset { + _WMDropResourcePlanRequest__isset() : resourcePlanName(false), ns(false) {} + bool resourcePlanName :1; + bool ns :1; +} _WMDropResourcePlanRequest__isset; + +class WMDropResourcePlanRequest : public virtual ::apache::thrift::TBase { + public: + + WMDropResourcePlanRequest(const WMDropResourcePlanRequest&); + WMDropResourcePlanRequest& operator=(const WMDropResourcePlanRequest&); + WMDropResourcePlanRequest() noexcept; + + virtual ~WMDropResourcePlanRequest() noexcept; + std::string resourcePlanName; + std::string ns; + + _WMDropResourcePlanRequest__isset __isset; + + void __set_resourcePlanName(const std::string& val); + + void __set_ns(const std::string& val); + + bool operator == (const WMDropResourcePlanRequest & rhs) const; + bool operator != (const WMDropResourcePlanRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMDropResourcePlanRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMDropResourcePlanRequest &a, WMDropResourcePlanRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMDropResourcePlanRequest& obj); + + +class WMDropResourcePlanResponse : public virtual ::apache::thrift::TBase { + public: + + WMDropResourcePlanResponse(const WMDropResourcePlanResponse&) noexcept; + WMDropResourcePlanResponse& operator=(const WMDropResourcePlanResponse&) noexcept; + WMDropResourcePlanResponse() noexcept; + + virtual ~WMDropResourcePlanResponse() noexcept; + + bool operator == (const WMDropResourcePlanResponse & /* rhs */) const; + bool operator != (const WMDropResourcePlanResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMDropResourcePlanResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMDropResourcePlanResponse &a, WMDropResourcePlanResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMDropResourcePlanResponse& obj); + +typedef struct _WMCreateTriggerRequest__isset { + _WMCreateTriggerRequest__isset() : trigger(false) {} + bool trigger :1; +} _WMCreateTriggerRequest__isset; + +class WMCreateTriggerRequest : public virtual ::apache::thrift::TBase { + public: + + WMCreateTriggerRequest(const WMCreateTriggerRequest&); + WMCreateTriggerRequest& operator=(const WMCreateTriggerRequest&); + WMCreateTriggerRequest() noexcept; + + virtual ~WMCreateTriggerRequest() noexcept; + WMTrigger trigger; + + _WMCreateTriggerRequest__isset __isset; + + void __set_trigger(const WMTrigger& val); + + bool operator == (const WMCreateTriggerRequest & rhs) const; + bool operator != (const WMCreateTriggerRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMCreateTriggerRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMCreateTriggerRequest &a, WMCreateTriggerRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMCreateTriggerRequest& obj); + + +class WMCreateTriggerResponse : public virtual ::apache::thrift::TBase { + public: + + WMCreateTriggerResponse(const WMCreateTriggerResponse&) noexcept; + WMCreateTriggerResponse& operator=(const WMCreateTriggerResponse&) noexcept; + WMCreateTriggerResponse() noexcept; + + virtual ~WMCreateTriggerResponse() noexcept; + + bool operator == (const WMCreateTriggerResponse & /* rhs */) const; + bool operator != (const WMCreateTriggerResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMCreateTriggerResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMCreateTriggerResponse &a, WMCreateTriggerResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMCreateTriggerResponse& obj); + +typedef struct _WMAlterTriggerRequest__isset { + _WMAlterTriggerRequest__isset() : trigger(false) {} + bool trigger :1; +} _WMAlterTriggerRequest__isset; + +class WMAlterTriggerRequest : public virtual ::apache::thrift::TBase { + public: + + WMAlterTriggerRequest(const WMAlterTriggerRequest&); + WMAlterTriggerRequest& operator=(const WMAlterTriggerRequest&); + WMAlterTriggerRequest() noexcept; + + virtual ~WMAlterTriggerRequest() noexcept; + WMTrigger trigger; + + _WMAlterTriggerRequest__isset __isset; + + void __set_trigger(const WMTrigger& val); + + bool operator == (const WMAlterTriggerRequest & rhs) const; + bool operator != (const WMAlterTriggerRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMAlterTriggerRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMAlterTriggerRequest &a, WMAlterTriggerRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMAlterTriggerRequest& obj); + + +class WMAlterTriggerResponse : public virtual ::apache::thrift::TBase { + public: + + WMAlterTriggerResponse(const WMAlterTriggerResponse&) noexcept; + WMAlterTriggerResponse& operator=(const WMAlterTriggerResponse&) noexcept; + WMAlterTriggerResponse() noexcept; + + virtual ~WMAlterTriggerResponse() noexcept; + + bool operator == (const WMAlterTriggerResponse & /* rhs */) const; + bool operator != (const WMAlterTriggerResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMAlterTriggerResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMAlterTriggerResponse &a, WMAlterTriggerResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMAlterTriggerResponse& obj); + +typedef struct _WMDropTriggerRequest__isset { + _WMDropTriggerRequest__isset() : resourcePlanName(false), triggerName(false), ns(false) {} + bool resourcePlanName :1; + bool triggerName :1; + bool ns :1; +} _WMDropTriggerRequest__isset; + +class WMDropTriggerRequest : public virtual ::apache::thrift::TBase { + public: + + WMDropTriggerRequest(const WMDropTriggerRequest&); + WMDropTriggerRequest& operator=(const WMDropTriggerRequest&); + WMDropTriggerRequest() noexcept; + + virtual ~WMDropTriggerRequest() noexcept; + std::string resourcePlanName; + std::string triggerName; + std::string ns; + + _WMDropTriggerRequest__isset __isset; + + void __set_resourcePlanName(const std::string& val); + + void __set_triggerName(const std::string& val); + + void __set_ns(const std::string& val); + + bool operator == (const WMDropTriggerRequest & rhs) const; + bool operator != (const WMDropTriggerRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMDropTriggerRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMDropTriggerRequest &a, WMDropTriggerRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMDropTriggerRequest& obj); + + +class WMDropTriggerResponse : public virtual ::apache::thrift::TBase { + public: + + WMDropTriggerResponse(const WMDropTriggerResponse&) noexcept; + WMDropTriggerResponse& operator=(const WMDropTriggerResponse&) noexcept; + WMDropTriggerResponse() noexcept; + + virtual ~WMDropTriggerResponse() noexcept; + + bool operator == (const WMDropTriggerResponse & /* rhs */) const; + bool operator != (const WMDropTriggerResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMDropTriggerResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMDropTriggerResponse &a, WMDropTriggerResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMDropTriggerResponse& obj); + +typedef struct _WMGetTriggersForResourePlanRequest__isset { + _WMGetTriggersForResourePlanRequest__isset() : resourcePlanName(false), ns(false) {} + bool resourcePlanName :1; + bool ns :1; +} _WMGetTriggersForResourePlanRequest__isset; + +class WMGetTriggersForResourePlanRequest : public virtual ::apache::thrift::TBase { + public: + + WMGetTriggersForResourePlanRequest(const WMGetTriggersForResourePlanRequest&); + WMGetTriggersForResourePlanRequest& operator=(const WMGetTriggersForResourePlanRequest&); + WMGetTriggersForResourePlanRequest() noexcept; + + virtual ~WMGetTriggersForResourePlanRequest() noexcept; + std::string resourcePlanName; + std::string ns; + + _WMGetTriggersForResourePlanRequest__isset __isset; + + void __set_resourcePlanName(const std::string& val); + + void __set_ns(const std::string& val); + + bool operator == (const WMGetTriggersForResourePlanRequest & rhs) const; + bool operator != (const WMGetTriggersForResourePlanRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMGetTriggersForResourePlanRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMGetTriggersForResourePlanRequest &a, WMGetTriggersForResourePlanRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMGetTriggersForResourePlanRequest& obj); + +typedef struct _WMGetTriggersForResourePlanResponse__isset { + _WMGetTriggersForResourePlanResponse__isset() : triggers(false) {} + bool triggers :1; +} _WMGetTriggersForResourePlanResponse__isset; + +class WMGetTriggersForResourePlanResponse : public virtual ::apache::thrift::TBase { + public: + + WMGetTriggersForResourePlanResponse(const WMGetTriggersForResourePlanResponse&); + WMGetTriggersForResourePlanResponse& operator=(const WMGetTriggersForResourePlanResponse&); + WMGetTriggersForResourePlanResponse() noexcept; + + virtual ~WMGetTriggersForResourePlanResponse() noexcept; + std::vector triggers; + + _WMGetTriggersForResourePlanResponse__isset __isset; + + void __set_triggers(const std::vector & val); + + bool operator == (const WMGetTriggersForResourePlanResponse & rhs) const; + bool operator != (const WMGetTriggersForResourePlanResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMGetTriggersForResourePlanResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMGetTriggersForResourePlanResponse &a, WMGetTriggersForResourePlanResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMGetTriggersForResourePlanResponse& obj); + +typedef struct _WMCreatePoolRequest__isset { + _WMCreatePoolRequest__isset() : pool(false) {} + bool pool :1; +} _WMCreatePoolRequest__isset; + +class WMCreatePoolRequest : public virtual ::apache::thrift::TBase { + public: + + WMCreatePoolRequest(const WMCreatePoolRequest&); + WMCreatePoolRequest& operator=(const WMCreatePoolRequest&); + WMCreatePoolRequest() noexcept; + + virtual ~WMCreatePoolRequest() noexcept; + WMPool pool; + + _WMCreatePoolRequest__isset __isset; + + void __set_pool(const WMPool& val); + + bool operator == (const WMCreatePoolRequest & rhs) const; + bool operator != (const WMCreatePoolRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMCreatePoolRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMCreatePoolRequest &a, WMCreatePoolRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMCreatePoolRequest& obj); + + +class WMCreatePoolResponse : public virtual ::apache::thrift::TBase { + public: + + WMCreatePoolResponse(const WMCreatePoolResponse&) noexcept; + WMCreatePoolResponse& operator=(const WMCreatePoolResponse&) noexcept; + WMCreatePoolResponse() noexcept; + + virtual ~WMCreatePoolResponse() noexcept; + + bool operator == (const WMCreatePoolResponse & /* rhs */) const; + bool operator != (const WMCreatePoolResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMCreatePoolResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMCreatePoolResponse &a, WMCreatePoolResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMCreatePoolResponse& obj); + +typedef struct _WMAlterPoolRequest__isset { + _WMAlterPoolRequest__isset() : pool(false), poolPath(false) {} + bool pool :1; + bool poolPath :1; +} _WMAlterPoolRequest__isset; + +class WMAlterPoolRequest : public virtual ::apache::thrift::TBase { + public: + + WMAlterPoolRequest(const WMAlterPoolRequest&); + WMAlterPoolRequest& operator=(const WMAlterPoolRequest&); + WMAlterPoolRequest() noexcept; + + virtual ~WMAlterPoolRequest() noexcept; + WMNullablePool pool; + std::string poolPath; + + _WMAlterPoolRequest__isset __isset; + + void __set_pool(const WMNullablePool& val); + + void __set_poolPath(const std::string& val); + + bool operator == (const WMAlterPoolRequest & rhs) const; + bool operator != (const WMAlterPoolRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMAlterPoolRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMAlterPoolRequest &a, WMAlterPoolRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMAlterPoolRequest& obj); + + +class WMAlterPoolResponse : public virtual ::apache::thrift::TBase { + public: + + WMAlterPoolResponse(const WMAlterPoolResponse&) noexcept; + WMAlterPoolResponse& operator=(const WMAlterPoolResponse&) noexcept; + WMAlterPoolResponse() noexcept; + + virtual ~WMAlterPoolResponse() noexcept; + + bool operator == (const WMAlterPoolResponse & /* rhs */) const; + bool operator != (const WMAlterPoolResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMAlterPoolResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMAlterPoolResponse &a, WMAlterPoolResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMAlterPoolResponse& obj); + +typedef struct _WMDropPoolRequest__isset { + _WMDropPoolRequest__isset() : resourcePlanName(false), poolPath(false), ns(false) {} + bool resourcePlanName :1; + bool poolPath :1; + bool ns :1; +} _WMDropPoolRequest__isset; + +class WMDropPoolRequest : public virtual ::apache::thrift::TBase { + public: + + WMDropPoolRequest(const WMDropPoolRequest&); + WMDropPoolRequest& operator=(const WMDropPoolRequest&); + WMDropPoolRequest() noexcept; + + virtual ~WMDropPoolRequest() noexcept; + std::string resourcePlanName; + std::string poolPath; + std::string ns; + + _WMDropPoolRequest__isset __isset; + + void __set_resourcePlanName(const std::string& val); + + void __set_poolPath(const std::string& val); + + void __set_ns(const std::string& val); + + bool operator == (const WMDropPoolRequest & rhs) const; + bool operator != (const WMDropPoolRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMDropPoolRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMDropPoolRequest &a, WMDropPoolRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMDropPoolRequest& obj); + + +class WMDropPoolResponse : public virtual ::apache::thrift::TBase { + public: + + WMDropPoolResponse(const WMDropPoolResponse&) noexcept; + WMDropPoolResponse& operator=(const WMDropPoolResponse&) noexcept; + WMDropPoolResponse() noexcept; + + virtual ~WMDropPoolResponse() noexcept; + + bool operator == (const WMDropPoolResponse & /* rhs */) const; + bool operator != (const WMDropPoolResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMDropPoolResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMDropPoolResponse &a, WMDropPoolResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMDropPoolResponse& obj); + +typedef struct _WMCreateOrUpdateMappingRequest__isset { + _WMCreateOrUpdateMappingRequest__isset() : mapping(false), update(false) {} + bool mapping :1; + bool update :1; +} _WMCreateOrUpdateMappingRequest__isset; + +class WMCreateOrUpdateMappingRequest : public virtual ::apache::thrift::TBase { + public: + + WMCreateOrUpdateMappingRequest(const WMCreateOrUpdateMappingRequest&); + WMCreateOrUpdateMappingRequest& operator=(const WMCreateOrUpdateMappingRequest&); + WMCreateOrUpdateMappingRequest() noexcept; + + virtual ~WMCreateOrUpdateMappingRequest() noexcept; + WMMapping mapping; + bool update; + + _WMCreateOrUpdateMappingRequest__isset __isset; + + void __set_mapping(const WMMapping& val); + + void __set_update(const bool val); + + bool operator == (const WMCreateOrUpdateMappingRequest & rhs) const; + bool operator != (const WMCreateOrUpdateMappingRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMCreateOrUpdateMappingRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMCreateOrUpdateMappingRequest &a, WMCreateOrUpdateMappingRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMCreateOrUpdateMappingRequest& obj); + + +class WMCreateOrUpdateMappingResponse : public virtual ::apache::thrift::TBase { + public: + + WMCreateOrUpdateMappingResponse(const WMCreateOrUpdateMappingResponse&) noexcept; + WMCreateOrUpdateMappingResponse& operator=(const WMCreateOrUpdateMappingResponse&) noexcept; + WMCreateOrUpdateMappingResponse() noexcept; + + virtual ~WMCreateOrUpdateMappingResponse() noexcept; + + bool operator == (const WMCreateOrUpdateMappingResponse & /* rhs */) const; + bool operator != (const WMCreateOrUpdateMappingResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMCreateOrUpdateMappingResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMCreateOrUpdateMappingResponse &a, WMCreateOrUpdateMappingResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMCreateOrUpdateMappingResponse& obj); + +typedef struct _WMDropMappingRequest__isset { + _WMDropMappingRequest__isset() : mapping(false) {} + bool mapping :1; +} _WMDropMappingRequest__isset; + +class WMDropMappingRequest : public virtual ::apache::thrift::TBase { + public: + + WMDropMappingRequest(const WMDropMappingRequest&); + WMDropMappingRequest& operator=(const WMDropMappingRequest&); + WMDropMappingRequest() noexcept; + + virtual ~WMDropMappingRequest() noexcept; + WMMapping mapping; + + _WMDropMappingRequest__isset __isset; + + void __set_mapping(const WMMapping& val); + + bool operator == (const WMDropMappingRequest & rhs) const; + bool operator != (const WMDropMappingRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMDropMappingRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMDropMappingRequest &a, WMDropMappingRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMDropMappingRequest& obj); + + +class WMDropMappingResponse : public virtual ::apache::thrift::TBase { + public: + + WMDropMappingResponse(const WMDropMappingResponse&) noexcept; + WMDropMappingResponse& operator=(const WMDropMappingResponse&) noexcept; + WMDropMappingResponse() noexcept; + + virtual ~WMDropMappingResponse() noexcept; + + bool operator == (const WMDropMappingResponse & /* rhs */) const; + bool operator != (const WMDropMappingResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMDropMappingResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMDropMappingResponse &a, WMDropMappingResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMDropMappingResponse& obj); + +typedef struct _WMCreateOrDropTriggerToPoolMappingRequest__isset { + _WMCreateOrDropTriggerToPoolMappingRequest__isset() : resourcePlanName(false), triggerName(false), poolPath(false), drop(false), ns(false) {} + bool resourcePlanName :1; + bool triggerName :1; + bool poolPath :1; + bool drop :1; + bool ns :1; +} _WMCreateOrDropTriggerToPoolMappingRequest__isset; + +class WMCreateOrDropTriggerToPoolMappingRequest : public virtual ::apache::thrift::TBase { + public: + + WMCreateOrDropTriggerToPoolMappingRequest(const WMCreateOrDropTriggerToPoolMappingRequest&); + WMCreateOrDropTriggerToPoolMappingRequest& operator=(const WMCreateOrDropTriggerToPoolMappingRequest&); + WMCreateOrDropTriggerToPoolMappingRequest() noexcept; + + virtual ~WMCreateOrDropTriggerToPoolMappingRequest() noexcept; + std::string resourcePlanName; + std::string triggerName; + std::string poolPath; + bool drop; + std::string ns; + + _WMCreateOrDropTriggerToPoolMappingRequest__isset __isset; + + void __set_resourcePlanName(const std::string& val); + + void __set_triggerName(const std::string& val); + + void __set_poolPath(const std::string& val); + + void __set_drop(const bool val); + + void __set_ns(const std::string& val); + + bool operator == (const WMCreateOrDropTriggerToPoolMappingRequest & rhs) const; + bool operator != (const WMCreateOrDropTriggerToPoolMappingRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMCreateOrDropTriggerToPoolMappingRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMCreateOrDropTriggerToPoolMappingRequest &a, WMCreateOrDropTriggerToPoolMappingRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMCreateOrDropTriggerToPoolMappingRequest& obj); + + +class WMCreateOrDropTriggerToPoolMappingResponse : public virtual ::apache::thrift::TBase { + public: + + WMCreateOrDropTriggerToPoolMappingResponse(const WMCreateOrDropTriggerToPoolMappingResponse&) noexcept; + WMCreateOrDropTriggerToPoolMappingResponse& operator=(const WMCreateOrDropTriggerToPoolMappingResponse&) noexcept; + WMCreateOrDropTriggerToPoolMappingResponse() noexcept; + + virtual ~WMCreateOrDropTriggerToPoolMappingResponse() noexcept; + + bool operator == (const WMCreateOrDropTriggerToPoolMappingResponse & /* rhs */) const; + bool operator != (const WMCreateOrDropTriggerToPoolMappingResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMCreateOrDropTriggerToPoolMappingResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMCreateOrDropTriggerToPoolMappingResponse &a, WMCreateOrDropTriggerToPoolMappingResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const WMCreateOrDropTriggerToPoolMappingResponse& obj); + +typedef struct _ISchema__isset { + _ISchema__isset() : schemaType(false), name(false), catName(false), dbName(false), compatibility(false), validationLevel(false), canEvolve(false), schemaGroup(false), description(false) {} + bool schemaType :1; + bool name :1; + bool catName :1; + bool dbName :1; + bool compatibility :1; + bool validationLevel :1; + bool canEvolve :1; + bool schemaGroup :1; + bool description :1; +} _ISchema__isset; + +class ISchema : public virtual ::apache::thrift::TBase { + public: + + ISchema(const ISchema&); + ISchema& operator=(const ISchema&); + ISchema() noexcept; + + virtual ~ISchema() noexcept; + /** + * + * @see SchemaType + */ + SchemaType::type schemaType; + std::string name; + std::string catName; + std::string dbName; + /** + * + * @see SchemaCompatibility + */ + SchemaCompatibility::type compatibility; + /** + * + * @see SchemaValidation + */ + SchemaValidation::type validationLevel; + bool canEvolve; + std::string schemaGroup; + std::string description; + + _ISchema__isset __isset; + + void __set_schemaType(const SchemaType::type val); + + void __set_name(const std::string& val); + + void __set_catName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_compatibility(const SchemaCompatibility::type val); + + void __set_validationLevel(const SchemaValidation::type val); + + void __set_canEvolve(const bool val); + + void __set_schemaGroup(const std::string& val); + + void __set_description(const std::string& val); + + bool operator == (const ISchema & rhs) const; + bool operator != (const ISchema &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ISchema & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ISchema &a, ISchema &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ISchema& obj); + +typedef struct _ISchemaName__isset { + _ISchemaName__isset() : catName(false), dbName(false), schemaName(false) {} + bool catName :1; + bool dbName :1; + bool schemaName :1; +} _ISchemaName__isset; + +class ISchemaName : public virtual ::apache::thrift::TBase { + public: + + ISchemaName(const ISchemaName&); + ISchemaName& operator=(const ISchemaName&); + ISchemaName() noexcept; + + virtual ~ISchemaName() noexcept; + std::string catName; + std::string dbName; + std::string schemaName; + + _ISchemaName__isset __isset; + + void __set_catName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_schemaName(const std::string& val); + + bool operator == (const ISchemaName & rhs) const; + bool operator != (const ISchemaName &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ISchemaName & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ISchemaName &a, ISchemaName &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ISchemaName& obj); + +typedef struct _AlterISchemaRequest__isset { + _AlterISchemaRequest__isset() : name(false), newSchema(false) {} + bool name :1; + bool newSchema :1; +} _AlterISchemaRequest__isset; + +class AlterISchemaRequest : public virtual ::apache::thrift::TBase { + public: + + AlterISchemaRequest(const AlterISchemaRequest&); + AlterISchemaRequest& operator=(const AlterISchemaRequest&); + AlterISchemaRequest() noexcept; + + virtual ~AlterISchemaRequest() noexcept; + ISchemaName name; + ISchema newSchema; + + _AlterISchemaRequest__isset __isset; + + void __set_name(const ISchemaName& val); + + void __set_newSchema(const ISchema& val); + + bool operator == (const AlterISchemaRequest & rhs) const; + bool operator != (const AlterISchemaRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AlterISchemaRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AlterISchemaRequest &a, AlterISchemaRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AlterISchemaRequest& obj); + +typedef struct _SchemaVersion__isset { + _SchemaVersion__isset() : schema(false), version(false), createdAt(false), cols(false), state(false), description(false), schemaText(false), fingerprint(false), name(false), serDe(false) {} + bool schema :1; + bool version :1; + bool createdAt :1; + bool cols :1; + bool state :1; + bool description :1; + bool schemaText :1; + bool fingerprint :1; + bool name :1; + bool serDe :1; +} _SchemaVersion__isset; + +class SchemaVersion : public virtual ::apache::thrift::TBase { + public: + + SchemaVersion(const SchemaVersion&); + SchemaVersion& operator=(const SchemaVersion&); + SchemaVersion() noexcept; + + virtual ~SchemaVersion() noexcept; + ISchemaName schema; + int32_t version; + int64_t createdAt; + std::vector cols; + /** + * + * @see SchemaVersionState + */ + SchemaVersionState::type state; + std::string description; + std::string schemaText; + std::string fingerprint; + std::string name; + SerDeInfo serDe; + + _SchemaVersion__isset __isset; + + void __set_schema(const ISchemaName& val); + + void __set_version(const int32_t val); + + void __set_createdAt(const int64_t val); + + void __set_cols(const std::vector & val); + + void __set_state(const SchemaVersionState::type val); + + void __set_description(const std::string& val); + + void __set_schemaText(const std::string& val); + + void __set_fingerprint(const std::string& val); + + void __set_name(const std::string& val); + + void __set_serDe(const SerDeInfo& val); + + bool operator == (const SchemaVersion & rhs) const; + bool operator != (const SchemaVersion &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SchemaVersion & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(SchemaVersion &a, SchemaVersion &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const SchemaVersion& obj); + +typedef struct _SchemaVersionDescriptor__isset { + _SchemaVersionDescriptor__isset() : schema(false), version(false) {} + bool schema :1; + bool version :1; +} _SchemaVersionDescriptor__isset; + +class SchemaVersionDescriptor : public virtual ::apache::thrift::TBase { + public: + + SchemaVersionDescriptor(const SchemaVersionDescriptor&); + SchemaVersionDescriptor& operator=(const SchemaVersionDescriptor&); + SchemaVersionDescriptor() noexcept; + + virtual ~SchemaVersionDescriptor() noexcept; + ISchemaName schema; + int32_t version; + + _SchemaVersionDescriptor__isset __isset; + + void __set_schema(const ISchemaName& val); + + void __set_version(const int32_t val); + + bool operator == (const SchemaVersionDescriptor & rhs) const; + bool operator != (const SchemaVersionDescriptor &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SchemaVersionDescriptor & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(SchemaVersionDescriptor &a, SchemaVersionDescriptor &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const SchemaVersionDescriptor& obj); + +typedef struct _FindSchemasByColsRqst__isset { + _FindSchemasByColsRqst__isset() : colName(false), colNamespace(false), type(false) {} + bool colName :1; + bool colNamespace :1; + bool type :1; +} _FindSchemasByColsRqst__isset; + +class FindSchemasByColsRqst : public virtual ::apache::thrift::TBase { + public: + + FindSchemasByColsRqst(const FindSchemasByColsRqst&); + FindSchemasByColsRqst& operator=(const FindSchemasByColsRqst&); + FindSchemasByColsRqst() noexcept; + + virtual ~FindSchemasByColsRqst() noexcept; + std::string colName; + std::string colNamespace; + std::string type; + + _FindSchemasByColsRqst__isset __isset; + + void __set_colName(const std::string& val); + + void __set_colNamespace(const std::string& val); + + void __set_type(const std::string& val); + + bool operator == (const FindSchemasByColsRqst & rhs) const; + bool operator != (const FindSchemasByColsRqst &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FindSchemasByColsRqst & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(FindSchemasByColsRqst &a, FindSchemasByColsRqst &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const FindSchemasByColsRqst& obj); + +typedef struct _FindSchemasByColsResp__isset { + _FindSchemasByColsResp__isset() : schemaVersions(false) {} + bool schemaVersions :1; +} _FindSchemasByColsResp__isset; + +class FindSchemasByColsResp : public virtual ::apache::thrift::TBase { + public: + + FindSchemasByColsResp(const FindSchemasByColsResp&); + FindSchemasByColsResp& operator=(const FindSchemasByColsResp&); + FindSchemasByColsResp() noexcept; + + virtual ~FindSchemasByColsResp() noexcept; + std::vector schemaVersions; + + _FindSchemasByColsResp__isset __isset; + + void __set_schemaVersions(const std::vector & val); + + bool operator == (const FindSchemasByColsResp & rhs) const; + bool operator != (const FindSchemasByColsResp &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FindSchemasByColsResp & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(FindSchemasByColsResp &a, FindSchemasByColsResp &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const FindSchemasByColsResp& obj); + +typedef struct _MapSchemaVersionToSerdeRequest__isset { + _MapSchemaVersionToSerdeRequest__isset() : schemaVersion(false), serdeName(false) {} + bool schemaVersion :1; + bool serdeName :1; +} _MapSchemaVersionToSerdeRequest__isset; + +class MapSchemaVersionToSerdeRequest : public virtual ::apache::thrift::TBase { + public: + + MapSchemaVersionToSerdeRequest(const MapSchemaVersionToSerdeRequest&); + MapSchemaVersionToSerdeRequest& operator=(const MapSchemaVersionToSerdeRequest&); + MapSchemaVersionToSerdeRequest() noexcept; + + virtual ~MapSchemaVersionToSerdeRequest() noexcept; + SchemaVersionDescriptor schemaVersion; + std::string serdeName; + + _MapSchemaVersionToSerdeRequest__isset __isset; + + void __set_schemaVersion(const SchemaVersionDescriptor& val); + + void __set_serdeName(const std::string& val); + + bool operator == (const MapSchemaVersionToSerdeRequest & rhs) const; + bool operator != (const MapSchemaVersionToSerdeRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const MapSchemaVersionToSerdeRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(MapSchemaVersionToSerdeRequest &a, MapSchemaVersionToSerdeRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const MapSchemaVersionToSerdeRequest& obj); + +typedef struct _SetSchemaVersionStateRequest__isset { + _SetSchemaVersionStateRequest__isset() : schemaVersion(false), state(false) {} + bool schemaVersion :1; + bool state :1; +} _SetSchemaVersionStateRequest__isset; + +class SetSchemaVersionStateRequest : public virtual ::apache::thrift::TBase { + public: + + SetSchemaVersionStateRequest(const SetSchemaVersionStateRequest&); + SetSchemaVersionStateRequest& operator=(const SetSchemaVersionStateRequest&); + SetSchemaVersionStateRequest() noexcept; + + virtual ~SetSchemaVersionStateRequest() noexcept; + SchemaVersionDescriptor schemaVersion; + /** + * + * @see SchemaVersionState + */ + SchemaVersionState::type state; + + _SetSchemaVersionStateRequest__isset __isset; + + void __set_schemaVersion(const SchemaVersionDescriptor& val); + + void __set_state(const SchemaVersionState::type val); + + bool operator == (const SetSchemaVersionStateRequest & rhs) const; + bool operator != (const SetSchemaVersionStateRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SetSchemaVersionStateRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(SetSchemaVersionStateRequest &a, SetSchemaVersionStateRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const SetSchemaVersionStateRequest& obj); + +typedef struct _GetSerdeRequest__isset { + _GetSerdeRequest__isset() : serdeName(false) {} + bool serdeName :1; +} _GetSerdeRequest__isset; + +class GetSerdeRequest : public virtual ::apache::thrift::TBase { + public: + + GetSerdeRequest(const GetSerdeRequest&); + GetSerdeRequest& operator=(const GetSerdeRequest&); + GetSerdeRequest() noexcept; + + virtual ~GetSerdeRequest() noexcept; + std::string serdeName; + + _GetSerdeRequest__isset __isset; + + void __set_serdeName(const std::string& val); + + bool operator == (const GetSerdeRequest & rhs) const; + bool operator != (const GetSerdeRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetSerdeRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetSerdeRequest &a, GetSerdeRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetSerdeRequest& obj); + +typedef struct _RuntimeStat__isset { + _RuntimeStat__isset() : createTime(false) {} + bool createTime :1; +} _RuntimeStat__isset; + +class RuntimeStat : public virtual ::apache::thrift::TBase { + public: + + RuntimeStat(const RuntimeStat&); + RuntimeStat& operator=(const RuntimeStat&); + RuntimeStat() noexcept; + + virtual ~RuntimeStat() noexcept; + int32_t createTime; + int32_t weight; + std::string payload; + + _RuntimeStat__isset __isset; + + void __set_createTime(const int32_t val); + + void __set_weight(const int32_t val); + + void __set_payload(const std::string& val); + + bool operator == (const RuntimeStat & rhs) const; + bool operator != (const RuntimeStat &rhs) const { + return !(*this == rhs); + } + + bool operator < (const RuntimeStat & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(RuntimeStat &a, RuntimeStat &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const RuntimeStat& obj); + + +class GetRuntimeStatsRequest : public virtual ::apache::thrift::TBase { + public: + + GetRuntimeStatsRequest(const GetRuntimeStatsRequest&) noexcept; + GetRuntimeStatsRequest& operator=(const GetRuntimeStatsRequest&) noexcept; + GetRuntimeStatsRequest() noexcept; + + virtual ~GetRuntimeStatsRequest() noexcept; + int32_t maxWeight; + int32_t maxCreateTime; + + void __set_maxWeight(const int32_t val); + + void __set_maxCreateTime(const int32_t val); + + bool operator == (const GetRuntimeStatsRequest & rhs) const; + bool operator != (const GetRuntimeStatsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetRuntimeStatsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetRuntimeStatsRequest &a, GetRuntimeStatsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetRuntimeStatsRequest& obj); + +typedef struct _CreateTableRequest__isset { + _CreateTableRequest__isset() : envContext(false), primaryKeys(false), foreignKeys(false), uniqueConstraints(false), notNullConstraints(false), defaultConstraints(false), checkConstraints(false), processorCapabilities(false), processorIdentifier(false) {} + bool envContext :1; + bool primaryKeys :1; + bool foreignKeys :1; + bool uniqueConstraints :1; + bool notNullConstraints :1; + bool defaultConstraints :1; + bool checkConstraints :1; + bool processorCapabilities :1; + bool processorIdentifier :1; +} _CreateTableRequest__isset; + +class CreateTableRequest : public virtual ::apache::thrift::TBase { + public: + + CreateTableRequest(const CreateTableRequest&); + CreateTableRequest& operator=(const CreateTableRequest&); + CreateTableRequest() noexcept; + + virtual ~CreateTableRequest() noexcept; + Table table; + EnvironmentContext envContext; + std::vector primaryKeys; + std::vector foreignKeys; + std::vector uniqueConstraints; + std::vector notNullConstraints; + std::vector defaultConstraints; + std::vector checkConstraints; + std::vector processorCapabilities; + std::string processorIdentifier; + + _CreateTableRequest__isset __isset; + + void __set_table(const Table& val); + + void __set_envContext(const EnvironmentContext& val); + + void __set_primaryKeys(const std::vector & val); + + void __set_foreignKeys(const std::vector & val); + + void __set_uniqueConstraints(const std::vector & val); + + void __set_notNullConstraints(const std::vector & val); + + void __set_defaultConstraints(const std::vector & val); + + void __set_checkConstraints(const std::vector & val); + + void __set_processorCapabilities(const std::vector & val); + + void __set_processorIdentifier(const std::string& val); + + bool operator == (const CreateTableRequest & rhs) const; + bool operator != (const CreateTableRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CreateTableRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(CreateTableRequest &a, CreateTableRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const CreateTableRequest& obj); + +typedef struct _CreateDatabaseRequest__isset { + _CreateDatabaseRequest__isset() : description(false), locationUri(false), parameters(false), privileges(false), ownerName(false), ownerType(false), catalogName(false), createTime(false), managedLocationUri(false), type(false), dataConnectorName(false), remote_dbname(false) {} + bool description :1; + bool locationUri :1; + bool parameters :1; + bool privileges :1; + bool ownerName :1; + bool ownerType :1; + bool catalogName :1; + bool createTime :1; + bool managedLocationUri :1; + bool type :1; + bool dataConnectorName :1; + bool remote_dbname :1; +} _CreateDatabaseRequest__isset; + +class CreateDatabaseRequest : public virtual ::apache::thrift::TBase { + public: + + CreateDatabaseRequest(const CreateDatabaseRequest&); + CreateDatabaseRequest& operator=(const CreateDatabaseRequest&); + CreateDatabaseRequest() noexcept; + + virtual ~CreateDatabaseRequest() noexcept; + std::string databaseName; + std::string description; + std::string locationUri; + std::map parameters; + PrincipalPrivilegeSet privileges; + std::string ownerName; + /** + * + * @see PrincipalType + */ + PrincipalType::type ownerType; + std::string catalogName; + int32_t createTime; + std::string managedLocationUri; + /** + * + * @see DatabaseType + */ + DatabaseType::type type; + std::string dataConnectorName; + std::string remote_dbname; + + _CreateDatabaseRequest__isset __isset; + + void __set_databaseName(const std::string& val); + + void __set_description(const std::string& val); + + void __set_locationUri(const std::string& val); + + void __set_parameters(const std::map & val); + + void __set_privileges(const PrincipalPrivilegeSet& val); + + void __set_ownerName(const std::string& val); + + void __set_ownerType(const PrincipalType::type val); + + void __set_catalogName(const std::string& val); + + void __set_createTime(const int32_t val); + + void __set_managedLocationUri(const std::string& val); + + void __set_type(const DatabaseType::type val); + + void __set_dataConnectorName(const std::string& val); + + void __set_remote_dbname(const std::string& val); + + bool operator == (const CreateDatabaseRequest & rhs) const; + bool operator != (const CreateDatabaseRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CreateDatabaseRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(CreateDatabaseRequest &a, CreateDatabaseRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const CreateDatabaseRequest& obj); + + +class CreateDataConnectorRequest : public virtual ::apache::thrift::TBase { + public: + + CreateDataConnectorRequest(const CreateDataConnectorRequest&); + CreateDataConnectorRequest& operator=(const CreateDataConnectorRequest&); + CreateDataConnectorRequest() noexcept; + + virtual ~CreateDataConnectorRequest() noexcept; + DataConnector connector; + + void __set_connector(const DataConnector& val); + + bool operator == (const CreateDataConnectorRequest & rhs) const; + bool operator != (const CreateDataConnectorRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CreateDataConnectorRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(CreateDataConnectorRequest &a, CreateDataConnectorRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const CreateDataConnectorRequest& obj); + + +class GetDataConnectorRequest : public virtual ::apache::thrift::TBase { + public: + + GetDataConnectorRequest(const GetDataConnectorRequest&); + GetDataConnectorRequest& operator=(const GetDataConnectorRequest&); + GetDataConnectorRequest() noexcept; + + virtual ~GetDataConnectorRequest() noexcept; + std::string connectorName; + + void __set_connectorName(const std::string& val); + + bool operator == (const GetDataConnectorRequest & rhs) const; + bool operator != (const GetDataConnectorRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetDataConnectorRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetDataConnectorRequest &a, GetDataConnectorRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetDataConnectorRequest& obj); + + +class AlterDataConnectorRequest : public virtual ::apache::thrift::TBase { + public: + + AlterDataConnectorRequest(const AlterDataConnectorRequest&); + AlterDataConnectorRequest& operator=(const AlterDataConnectorRequest&); + AlterDataConnectorRequest() noexcept; + + virtual ~AlterDataConnectorRequest() noexcept; + std::string connectorName; + DataConnector newConnector; + + void __set_connectorName(const std::string& val); + + void __set_newConnector(const DataConnector& val); + + bool operator == (const AlterDataConnectorRequest & rhs) const; + bool operator != (const AlterDataConnectorRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AlterDataConnectorRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AlterDataConnectorRequest &a, AlterDataConnectorRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AlterDataConnectorRequest& obj); + +typedef struct _DropDataConnectorRequest__isset { + _DropDataConnectorRequest__isset() : ifNotExists(false), checkReferences(false) {} + bool ifNotExists :1; + bool checkReferences :1; +} _DropDataConnectorRequest__isset; + +class DropDataConnectorRequest : public virtual ::apache::thrift::TBase { + public: + + DropDataConnectorRequest(const DropDataConnectorRequest&); + DropDataConnectorRequest& operator=(const DropDataConnectorRequest&); + DropDataConnectorRequest() noexcept; + + virtual ~DropDataConnectorRequest() noexcept; + std::string connectorName; + bool ifNotExists; + bool checkReferences; + + _DropDataConnectorRequest__isset __isset; + + void __set_connectorName(const std::string& val); + + void __set_ifNotExists(const bool val); + + void __set_checkReferences(const bool val); + + bool operator == (const DropDataConnectorRequest & rhs) const; + bool operator != (const DropDataConnectorRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const DropDataConnectorRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(DropDataConnectorRequest &a, DropDataConnectorRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const DropDataConnectorRequest& obj); + + +class ScheduledQueryPollRequest : public virtual ::apache::thrift::TBase { + public: + + ScheduledQueryPollRequest(const ScheduledQueryPollRequest&); + ScheduledQueryPollRequest& operator=(const ScheduledQueryPollRequest&); + ScheduledQueryPollRequest() noexcept; + + virtual ~ScheduledQueryPollRequest() noexcept; + std::string clusterNamespace; + + void __set_clusterNamespace(const std::string& val); + + bool operator == (const ScheduledQueryPollRequest & rhs) const; + bool operator != (const ScheduledQueryPollRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ScheduledQueryPollRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ScheduledQueryPollRequest &a, ScheduledQueryPollRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ScheduledQueryPollRequest& obj); + + +class ScheduledQueryKey : public virtual ::apache::thrift::TBase { + public: + + ScheduledQueryKey(const ScheduledQueryKey&); + ScheduledQueryKey& operator=(const ScheduledQueryKey&); + ScheduledQueryKey() noexcept; + + virtual ~ScheduledQueryKey() noexcept; + std::string scheduleName; + std::string clusterNamespace; + + void __set_scheduleName(const std::string& val); + + void __set_clusterNamespace(const std::string& val); + + bool operator == (const ScheduledQueryKey & rhs) const; + bool operator != (const ScheduledQueryKey &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ScheduledQueryKey & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ScheduledQueryKey &a, ScheduledQueryKey &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ScheduledQueryKey& obj); + +typedef struct _ScheduledQueryPollResponse__isset { + _ScheduledQueryPollResponse__isset() : scheduleKey(false), executionId(false), query(false), user(false) {} + bool scheduleKey :1; + bool executionId :1; + bool query :1; + bool user :1; +} _ScheduledQueryPollResponse__isset; + +class ScheduledQueryPollResponse : public virtual ::apache::thrift::TBase { + public: + + ScheduledQueryPollResponse(const ScheduledQueryPollResponse&); + ScheduledQueryPollResponse& operator=(const ScheduledQueryPollResponse&); + ScheduledQueryPollResponse() noexcept; + + virtual ~ScheduledQueryPollResponse() noexcept; + ScheduledQueryKey scheduleKey; + int64_t executionId; + std::string query; + std::string user; + + _ScheduledQueryPollResponse__isset __isset; + + void __set_scheduleKey(const ScheduledQueryKey& val); + + void __set_executionId(const int64_t val); + + void __set_query(const std::string& val); + + void __set_user(const std::string& val); + + bool operator == (const ScheduledQueryPollResponse & rhs) const; + bool operator != (const ScheduledQueryPollResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ScheduledQueryPollResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ScheduledQueryPollResponse &a, ScheduledQueryPollResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ScheduledQueryPollResponse& obj); + +typedef struct _ScheduledQuery__isset { + _ScheduledQuery__isset() : enabled(false), schedule(false), user(false), query(false), nextExecution(false) {} + bool enabled :1; + bool schedule :1; + bool user :1; + bool query :1; + bool nextExecution :1; +} _ScheduledQuery__isset; + +class ScheduledQuery : public virtual ::apache::thrift::TBase { + public: + + ScheduledQuery(const ScheduledQuery&); + ScheduledQuery& operator=(const ScheduledQuery&); + ScheduledQuery() noexcept; + + virtual ~ScheduledQuery() noexcept; + ScheduledQueryKey scheduleKey; + bool enabled; + std::string schedule; + std::string user; + std::string query; + int32_t nextExecution; + + _ScheduledQuery__isset __isset; + + void __set_scheduleKey(const ScheduledQueryKey& val); + + void __set_enabled(const bool val); + + void __set_schedule(const std::string& val); + + void __set_user(const std::string& val); + + void __set_query(const std::string& val); + + void __set_nextExecution(const int32_t val); + + bool operator == (const ScheduledQuery & rhs) const; + bool operator != (const ScheduledQuery &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ScheduledQuery & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ScheduledQuery &a, ScheduledQuery &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ScheduledQuery& obj); + + +class ScheduledQueryMaintenanceRequest : public virtual ::apache::thrift::TBase { + public: + + ScheduledQueryMaintenanceRequest(const ScheduledQueryMaintenanceRequest&); + ScheduledQueryMaintenanceRequest& operator=(const ScheduledQueryMaintenanceRequest&); + ScheduledQueryMaintenanceRequest() noexcept; + + virtual ~ScheduledQueryMaintenanceRequest() noexcept; + /** + * + * @see ScheduledQueryMaintenanceRequestType + */ + ScheduledQueryMaintenanceRequestType::type type; + ScheduledQuery scheduledQuery; + + void __set_type(const ScheduledQueryMaintenanceRequestType::type val); + + void __set_scheduledQuery(const ScheduledQuery& val); + + bool operator == (const ScheduledQueryMaintenanceRequest & rhs) const; + bool operator != (const ScheduledQueryMaintenanceRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ScheduledQueryMaintenanceRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ScheduledQueryMaintenanceRequest &a, ScheduledQueryMaintenanceRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ScheduledQueryMaintenanceRequest& obj); + +typedef struct _ScheduledQueryProgressInfo__isset { + _ScheduledQueryProgressInfo__isset() : errorMessage(false) {} + bool errorMessage :1; +} _ScheduledQueryProgressInfo__isset; + +class ScheduledQueryProgressInfo : public virtual ::apache::thrift::TBase { + public: + + ScheduledQueryProgressInfo(const ScheduledQueryProgressInfo&); + ScheduledQueryProgressInfo& operator=(const ScheduledQueryProgressInfo&); + ScheduledQueryProgressInfo() noexcept; + + virtual ~ScheduledQueryProgressInfo() noexcept; + int64_t scheduledExecutionId; + /** + * + * @see QueryState + */ + QueryState::type state; + std::string executorQueryId; + std::string errorMessage; + + _ScheduledQueryProgressInfo__isset __isset; + + void __set_scheduledExecutionId(const int64_t val); + + void __set_state(const QueryState::type val); + + void __set_executorQueryId(const std::string& val); + + void __set_errorMessage(const std::string& val); + + bool operator == (const ScheduledQueryProgressInfo & rhs) const; + bool operator != (const ScheduledQueryProgressInfo &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ScheduledQueryProgressInfo & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ScheduledQueryProgressInfo &a, ScheduledQueryProgressInfo &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ScheduledQueryProgressInfo& obj); + +typedef struct _AlterPartitionsRequest__isset { + _AlterPartitionsRequest__isset() : catName(false), environmentContext(false), writeId(true), validWriteIdList(false), skipColumnSchemaForPartition(false), partitionColSchema(false) {} + bool catName :1; + bool environmentContext :1; + bool writeId :1; + bool validWriteIdList :1; + bool skipColumnSchemaForPartition :1; + bool partitionColSchema :1; +} _AlterPartitionsRequest__isset; + +class AlterPartitionsRequest : public virtual ::apache::thrift::TBase { + public: + + AlterPartitionsRequest(const AlterPartitionsRequest&); + AlterPartitionsRequest& operator=(const AlterPartitionsRequest&); + AlterPartitionsRequest() noexcept; + + virtual ~AlterPartitionsRequest() noexcept; + std::string catName; + std::string dbName; + std::string tableName; + std::vector partitions; + EnvironmentContext environmentContext; + int64_t writeId; + std::string validWriteIdList; + bool skipColumnSchemaForPartition; + std::vector partitionColSchema; + + _AlterPartitionsRequest__isset __isset; + + void __set_catName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_tableName(const std::string& val); + + void __set_partitions(const std::vector & val); + + void __set_environmentContext(const EnvironmentContext& val); + + void __set_writeId(const int64_t val); + + void __set_validWriteIdList(const std::string& val); + + void __set_skipColumnSchemaForPartition(const bool val); + + void __set_partitionColSchema(const std::vector & val); + + bool operator == (const AlterPartitionsRequest & rhs) const; + bool operator != (const AlterPartitionsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AlterPartitionsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AlterPartitionsRequest &a, AlterPartitionsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AlterPartitionsRequest& obj); + +typedef struct _AppendPartitionsRequest__isset { + _AppendPartitionsRequest__isset() : catalogName(false), name(false), partVals(false), environmentContext(false) {} + bool catalogName :1; + bool name :1; + bool partVals :1; + bool environmentContext :1; +} _AppendPartitionsRequest__isset; + +class AppendPartitionsRequest : public virtual ::apache::thrift::TBase { + public: + + AppendPartitionsRequest(const AppendPartitionsRequest&); + AppendPartitionsRequest& operator=(const AppendPartitionsRequest&); + AppendPartitionsRequest() noexcept; + + virtual ~AppendPartitionsRequest() noexcept; + std::string catalogName; + std::string dbName; + std::string tableName; + std::string name; + std::vector partVals; + EnvironmentContext environmentContext; + + _AppendPartitionsRequest__isset __isset; + + void __set_catalogName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_tableName(const std::string& val); + + void __set_name(const std::string& val); + + void __set_partVals(const std::vector & val); + + void __set_environmentContext(const EnvironmentContext& val); + + bool operator == (const AppendPartitionsRequest & rhs) const; + bool operator != (const AppendPartitionsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AppendPartitionsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AppendPartitionsRequest &a, AppendPartitionsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AppendPartitionsRequest& obj); + + +class AlterPartitionsResponse : public virtual ::apache::thrift::TBase { + public: + + AlterPartitionsResponse(const AlterPartitionsResponse&) noexcept; + AlterPartitionsResponse& operator=(const AlterPartitionsResponse&) noexcept; + AlterPartitionsResponse() noexcept; + + virtual ~AlterPartitionsResponse() noexcept; + + bool operator == (const AlterPartitionsResponse & /* rhs */) const; + bool operator != (const AlterPartitionsResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AlterPartitionsResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AlterPartitionsResponse &a, AlterPartitionsResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AlterPartitionsResponse& obj); + +typedef struct _RenamePartitionRequest__isset { + _RenamePartitionRequest__isset() : catName(false), validWriteIdList(false), txnId(false), clonePart(false) {} + bool catName :1; + bool validWriteIdList :1; + bool txnId :1; + bool clonePart :1; +} _RenamePartitionRequest__isset; + +class RenamePartitionRequest : public virtual ::apache::thrift::TBase { + public: + + RenamePartitionRequest(const RenamePartitionRequest&); + RenamePartitionRequest& operator=(const RenamePartitionRequest&); + RenamePartitionRequest() noexcept; + + virtual ~RenamePartitionRequest() noexcept; + std::string catName; + std::string dbName; + std::string tableName; + std::vector partVals; + Partition newPart; + std::string validWriteIdList; + int64_t txnId; + bool clonePart; + + _RenamePartitionRequest__isset __isset; + + void __set_catName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_tableName(const std::string& val); + + void __set_partVals(const std::vector & val); + + void __set_newPart(const Partition& val); + + void __set_validWriteIdList(const std::string& val); + + void __set_txnId(const int64_t val); + + void __set_clonePart(const bool val); + + bool operator == (const RenamePartitionRequest & rhs) const; + bool operator != (const RenamePartitionRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const RenamePartitionRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(RenamePartitionRequest &a, RenamePartitionRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const RenamePartitionRequest& obj); + + +class RenamePartitionResponse : public virtual ::apache::thrift::TBase { + public: + + RenamePartitionResponse(const RenamePartitionResponse&) noexcept; + RenamePartitionResponse& operator=(const RenamePartitionResponse&) noexcept; + RenamePartitionResponse() noexcept; + + virtual ~RenamePartitionResponse() noexcept; + + bool operator == (const RenamePartitionResponse & /* rhs */) const; + bool operator != (const RenamePartitionResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const RenamePartitionResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(RenamePartitionResponse &a, RenamePartitionResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const RenamePartitionResponse& obj); + +typedef struct _AlterTableRequest__isset { + _AlterTableRequest__isset() : catName(false), environmentContext(false), writeId(true), validWriteIdList(false), processorCapabilities(false), processorIdentifier(false), expectedParameterKey(false), expectedParameterValue(false) {} + bool catName :1; + bool environmentContext :1; + bool writeId :1; + bool validWriteIdList :1; + bool processorCapabilities :1; + bool processorIdentifier :1; + bool expectedParameterKey :1; + bool expectedParameterValue :1; +} _AlterTableRequest__isset; + +class AlterTableRequest : public virtual ::apache::thrift::TBase { + public: + + AlterTableRequest(const AlterTableRequest&); + AlterTableRequest& operator=(const AlterTableRequest&); + AlterTableRequest() noexcept; + + virtual ~AlterTableRequest() noexcept; + std::string catName; + std::string dbName; + std::string tableName; + Table table; + EnvironmentContext environmentContext; + int64_t writeId; + std::string validWriteIdList; + std::vector processorCapabilities; + std::string processorIdentifier; + std::string expectedParameterKey; + std::string expectedParameterValue; + + _AlterTableRequest__isset __isset; + + void __set_catName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_tableName(const std::string& val); + + void __set_table(const Table& val); + + void __set_environmentContext(const EnvironmentContext& val); + + void __set_writeId(const int64_t val); + + void __set_validWriteIdList(const std::string& val); + + void __set_processorCapabilities(const std::vector & val); + + void __set_processorIdentifier(const std::string& val); + + void __set_expectedParameterKey(const std::string& val); + + void __set_expectedParameterValue(const std::string& val); + + bool operator == (const AlterTableRequest & rhs) const; + bool operator != (const AlterTableRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AlterTableRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AlterTableRequest &a, AlterTableRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AlterTableRequest& obj); + + +class AlterTableResponse : public virtual ::apache::thrift::TBase { + public: + + AlterTableResponse(const AlterTableResponse&) noexcept; + AlterTableResponse& operator=(const AlterTableResponse&) noexcept; + AlterTableResponse() noexcept; + + virtual ~AlterTableResponse() noexcept; + + bool operator == (const AlterTableResponse & /* rhs */) const; + bool operator != (const AlterTableResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AlterTableResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AlterTableResponse &a, AlterTableResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AlterTableResponse& obj); + +typedef struct _GetPartitionsFilterSpec__isset { + _GetPartitionsFilterSpec__isset() : filterMode(false), filters(false) {} + bool filterMode :1; + bool filters :1; +} _GetPartitionsFilterSpec__isset; + +class GetPartitionsFilterSpec : public virtual ::apache::thrift::TBase { + public: + + GetPartitionsFilterSpec(const GetPartitionsFilterSpec&); + GetPartitionsFilterSpec& operator=(const GetPartitionsFilterSpec&); + GetPartitionsFilterSpec() noexcept; + + virtual ~GetPartitionsFilterSpec() noexcept; + /** + * + * @see PartitionFilterMode + */ + PartitionFilterMode::type filterMode; + std::vector filters; + + _GetPartitionsFilterSpec__isset __isset; + + void __set_filterMode(const PartitionFilterMode::type val); + + void __set_filters(const std::vector & val); + + bool operator == (const GetPartitionsFilterSpec & rhs) const; + bool operator != (const GetPartitionsFilterSpec &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetPartitionsFilterSpec & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetPartitionsFilterSpec &a, GetPartitionsFilterSpec &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetPartitionsFilterSpec& obj); + +typedef struct _GetPartitionsResponse__isset { + _GetPartitionsResponse__isset() : partitionSpec(false) {} + bool partitionSpec :1; +} _GetPartitionsResponse__isset; + +class GetPartitionsResponse : public virtual ::apache::thrift::TBase { + public: + + GetPartitionsResponse(const GetPartitionsResponse&); + GetPartitionsResponse& operator=(const GetPartitionsResponse&); + GetPartitionsResponse() noexcept; + + virtual ~GetPartitionsResponse() noexcept; + std::vector partitionSpec; + + _GetPartitionsResponse__isset __isset; + + void __set_partitionSpec(const std::vector & val); + + bool operator == (const GetPartitionsResponse & rhs) const; + bool operator != (const GetPartitionsResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetPartitionsResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetPartitionsResponse &a, GetPartitionsResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetPartitionsResponse& obj); + +typedef struct _GetPartitionsRequest__isset { + _GetPartitionsRequest__isset() : catName(false), dbName(false), tblName(false), withAuth(false), user(false), groupNames(false), projectionSpec(false), filterSpec(false), processorCapabilities(false), processorIdentifier(false), validWriteIdList(false) {} + bool catName :1; + bool dbName :1; + bool tblName :1; + bool withAuth :1; + bool user :1; + bool groupNames :1; + bool projectionSpec :1; + bool filterSpec :1; + bool processorCapabilities :1; + bool processorIdentifier :1; + bool validWriteIdList :1; +} _GetPartitionsRequest__isset; + +class GetPartitionsRequest : public virtual ::apache::thrift::TBase { + public: + + GetPartitionsRequest(const GetPartitionsRequest&); + GetPartitionsRequest& operator=(const GetPartitionsRequest&); + GetPartitionsRequest() noexcept; + + virtual ~GetPartitionsRequest() noexcept; + std::string catName; + std::string dbName; + std::string tblName; + bool withAuth; + std::string user; + std::vector groupNames; + GetProjectionsSpec projectionSpec; + GetPartitionsFilterSpec filterSpec; + std::vector processorCapabilities; + std::string processorIdentifier; + std::string validWriteIdList; + + _GetPartitionsRequest__isset __isset; + + void __set_catName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_tblName(const std::string& val); + + void __set_withAuth(const bool val); + + void __set_user(const std::string& val); + + void __set_groupNames(const std::vector & val); + + void __set_projectionSpec(const GetProjectionsSpec& val); + + void __set_filterSpec(const GetPartitionsFilterSpec& val); + + void __set_processorCapabilities(const std::vector & val); + + void __set_processorIdentifier(const std::string& val); + + void __set_validWriteIdList(const std::string& val); + + bool operator == (const GetPartitionsRequest & rhs) const; + bool operator != (const GetPartitionsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetPartitionsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetPartitionsRequest &a, GetPartitionsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetPartitionsRequest& obj); + +typedef struct _GetFieldsRequest__isset { + _GetFieldsRequest__isset() : catName(false), envContext(false), validWriteIdList(false), id(true) {} + bool catName :1; + bool envContext :1; + bool validWriteIdList :1; + bool id :1; +} _GetFieldsRequest__isset; + +class GetFieldsRequest : public virtual ::apache::thrift::TBase { + public: + + GetFieldsRequest(const GetFieldsRequest&); + GetFieldsRequest& operator=(const GetFieldsRequest&); + GetFieldsRequest() noexcept; + + virtual ~GetFieldsRequest() noexcept; + std::string catName; + std::string dbName; + std::string tblName; + EnvironmentContext envContext; + std::string validWriteIdList; + int64_t id; + + _GetFieldsRequest__isset __isset; + + void __set_catName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_tblName(const std::string& val); + + void __set_envContext(const EnvironmentContext& val); + + void __set_validWriteIdList(const std::string& val); + + void __set_id(const int64_t val); + + bool operator == (const GetFieldsRequest & rhs) const; + bool operator != (const GetFieldsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetFieldsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetFieldsRequest &a, GetFieldsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetFieldsRequest& obj); + + +class GetFieldsResponse : public virtual ::apache::thrift::TBase { + public: + + GetFieldsResponse(const GetFieldsResponse&); + GetFieldsResponse& operator=(const GetFieldsResponse&); + GetFieldsResponse() noexcept; + + virtual ~GetFieldsResponse() noexcept; + std::vector fields; + + void __set_fields(const std::vector & val); + + bool operator == (const GetFieldsResponse & rhs) const; + bool operator != (const GetFieldsResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetFieldsResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetFieldsResponse &a, GetFieldsResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetFieldsResponse& obj); + +typedef struct _GetSchemaRequest__isset { + _GetSchemaRequest__isset() : catName(false), envContext(false), validWriteIdList(false), id(true) {} + bool catName :1; + bool envContext :1; + bool validWriteIdList :1; + bool id :1; +} _GetSchemaRequest__isset; + +class GetSchemaRequest : public virtual ::apache::thrift::TBase { + public: + + GetSchemaRequest(const GetSchemaRequest&); + GetSchemaRequest& operator=(const GetSchemaRequest&); + GetSchemaRequest() noexcept; + + virtual ~GetSchemaRequest() noexcept; + std::string catName; + std::string dbName; + std::string tblName; + EnvironmentContext envContext; + std::string validWriteIdList; + int64_t id; + + _GetSchemaRequest__isset __isset; + + void __set_catName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_tblName(const std::string& val); + + void __set_envContext(const EnvironmentContext& val); + + void __set_validWriteIdList(const std::string& val); + + void __set_id(const int64_t val); + + bool operator == (const GetSchemaRequest & rhs) const; + bool operator != (const GetSchemaRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetSchemaRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetSchemaRequest &a, GetSchemaRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetSchemaRequest& obj); + + +class GetSchemaResponse : public virtual ::apache::thrift::TBase { + public: + + GetSchemaResponse(const GetSchemaResponse&); + GetSchemaResponse& operator=(const GetSchemaResponse&); + GetSchemaResponse() noexcept; + + virtual ~GetSchemaResponse() noexcept; + std::vector fields; + + void __set_fields(const std::vector & val); + + bool operator == (const GetSchemaResponse & rhs) const; + bool operator != (const GetSchemaResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetSchemaResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetSchemaResponse &a, GetSchemaResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetSchemaResponse& obj); + +typedef struct _GetPartitionRequest__isset { + _GetPartitionRequest__isset() : catName(false), validWriteIdList(false), id(true) {} + bool catName :1; + bool validWriteIdList :1; + bool id :1; +} _GetPartitionRequest__isset; + +class GetPartitionRequest : public virtual ::apache::thrift::TBase { + public: + + GetPartitionRequest(const GetPartitionRequest&); + GetPartitionRequest& operator=(const GetPartitionRequest&); + GetPartitionRequest() noexcept; + + virtual ~GetPartitionRequest() noexcept; + std::string catName; + std::string dbName; + std::string tblName; + std::vector partVals; + std::string validWriteIdList; + int64_t id; + + _GetPartitionRequest__isset __isset; + + void __set_catName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_tblName(const std::string& val); + + void __set_partVals(const std::vector & val); + + void __set_validWriteIdList(const std::string& val); + + void __set_id(const int64_t val); + + bool operator == (const GetPartitionRequest & rhs) const; + bool operator != (const GetPartitionRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetPartitionRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetPartitionRequest &a, GetPartitionRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetPartitionRequest& obj); + + +class GetPartitionResponse : public virtual ::apache::thrift::TBase { + public: + + GetPartitionResponse(const GetPartitionResponse&); + GetPartitionResponse& operator=(const GetPartitionResponse&); + GetPartitionResponse() noexcept; + + virtual ~GetPartitionResponse() noexcept; + Partition partition; + + void __set_partition(const Partition& val); + + bool operator == (const GetPartitionResponse & rhs) const; + bool operator != (const GetPartitionResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetPartitionResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetPartitionResponse &a, GetPartitionResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetPartitionResponse& obj); + +typedef struct _PartitionsRequest__isset { + _PartitionsRequest__isset() : catName(false), maxParts(true), validWriteIdList(false), id(true), skipColumnSchemaForPartition(false), includeParamKeyPattern(false), excludeParamKeyPattern(false) {} + bool catName :1; + bool maxParts :1; + bool validWriteIdList :1; + bool id :1; + bool skipColumnSchemaForPartition :1; + bool includeParamKeyPattern :1; + bool excludeParamKeyPattern :1; +} _PartitionsRequest__isset; + +class PartitionsRequest : public virtual ::apache::thrift::TBase { + public: + + PartitionsRequest(const PartitionsRequest&); + PartitionsRequest& operator=(const PartitionsRequest&); + PartitionsRequest() noexcept; + + virtual ~PartitionsRequest() noexcept; + std::string catName; + std::string dbName; + std::string tblName; + int16_t maxParts; + std::string validWriteIdList; + int64_t id; + bool skipColumnSchemaForPartition; + std::string includeParamKeyPattern; + std::string excludeParamKeyPattern; + + _PartitionsRequest__isset __isset; + + void __set_catName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_tblName(const std::string& val); + + void __set_maxParts(const int16_t val); + + void __set_validWriteIdList(const std::string& val); + + void __set_id(const int64_t val); + + void __set_skipColumnSchemaForPartition(const bool val); + + void __set_includeParamKeyPattern(const std::string& val); + + void __set_excludeParamKeyPattern(const std::string& val); + + bool operator == (const PartitionsRequest & rhs) const; + bool operator != (const PartitionsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PartitionsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PartitionsRequest &a, PartitionsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PartitionsRequest& obj); + + +class PartitionsResponse : public virtual ::apache::thrift::TBase { + public: + + PartitionsResponse(const PartitionsResponse&); + PartitionsResponse& operator=(const PartitionsResponse&); + PartitionsResponse() noexcept; + + virtual ~PartitionsResponse() noexcept; + std::vector partitions; + + void __set_partitions(const std::vector & val); + + bool operator == (const PartitionsResponse & rhs) const; + bool operator != (const PartitionsResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PartitionsResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PartitionsResponse &a, PartitionsResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const PartitionsResponse& obj); + +typedef struct _GetPartitionsByFilterRequest__isset { + _GetPartitionsByFilterRequest__isset() : catName(false), dbName(false), tblName(false), filter(false), maxParts(true), skipColumnSchemaForPartition(false), includeParamKeyPattern(false), excludeParamKeyPattern(false) {} + bool catName :1; + bool dbName :1; + bool tblName :1; + bool filter :1; + bool maxParts :1; + bool skipColumnSchemaForPartition :1; + bool includeParamKeyPattern :1; + bool excludeParamKeyPattern :1; +} _GetPartitionsByFilterRequest__isset; + +class GetPartitionsByFilterRequest : public virtual ::apache::thrift::TBase { + public: + + GetPartitionsByFilterRequest(const GetPartitionsByFilterRequest&); + GetPartitionsByFilterRequest& operator=(const GetPartitionsByFilterRequest&); + GetPartitionsByFilterRequest() noexcept; + + virtual ~GetPartitionsByFilterRequest() noexcept; + std::string catName; + std::string dbName; + std::string tblName; + std::string filter; + int16_t maxParts; + bool skipColumnSchemaForPartition; + std::string includeParamKeyPattern; + std::string excludeParamKeyPattern; + + _GetPartitionsByFilterRequest__isset __isset; + + void __set_catName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_tblName(const std::string& val); + + void __set_filter(const std::string& val); + + void __set_maxParts(const int16_t val); + + void __set_skipColumnSchemaForPartition(const bool val); + + void __set_includeParamKeyPattern(const std::string& val); + + void __set_excludeParamKeyPattern(const std::string& val); + + bool operator == (const GetPartitionsByFilterRequest & rhs) const; + bool operator != (const GetPartitionsByFilterRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetPartitionsByFilterRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetPartitionsByFilterRequest &a, GetPartitionsByFilterRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetPartitionsByFilterRequest& obj); + +typedef struct _GetPartitionNamesPsRequest__isset { + _GetPartitionNamesPsRequest__isset() : catName(false), partValues(false), maxParts(true), validWriteIdList(false), id(true) {} + bool catName :1; + bool partValues :1; + bool maxParts :1; + bool validWriteIdList :1; + bool id :1; +} _GetPartitionNamesPsRequest__isset; + +class GetPartitionNamesPsRequest : public virtual ::apache::thrift::TBase { + public: + + GetPartitionNamesPsRequest(const GetPartitionNamesPsRequest&); + GetPartitionNamesPsRequest& operator=(const GetPartitionNamesPsRequest&); + GetPartitionNamesPsRequest() noexcept; + + virtual ~GetPartitionNamesPsRequest() noexcept; + std::string catName; + std::string dbName; + std::string tblName; + std::vector partValues; + int16_t maxParts; + std::string validWriteIdList; + int64_t id; + + _GetPartitionNamesPsRequest__isset __isset; + + void __set_catName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_tblName(const std::string& val); + + void __set_partValues(const std::vector & val); + + void __set_maxParts(const int16_t val); + + void __set_validWriteIdList(const std::string& val); + + void __set_id(const int64_t val); + + bool operator == (const GetPartitionNamesPsRequest & rhs) const; + bool operator != (const GetPartitionNamesPsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetPartitionNamesPsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetPartitionNamesPsRequest &a, GetPartitionNamesPsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetPartitionNamesPsRequest& obj); + + +class GetPartitionNamesPsResponse : public virtual ::apache::thrift::TBase { + public: + + GetPartitionNamesPsResponse(const GetPartitionNamesPsResponse&); + GetPartitionNamesPsResponse& operator=(const GetPartitionNamesPsResponse&); + GetPartitionNamesPsResponse() noexcept; + + virtual ~GetPartitionNamesPsResponse() noexcept; + std::vector names; + + void __set_names(const std::vector & val); + + bool operator == (const GetPartitionNamesPsResponse & rhs) const; + bool operator != (const GetPartitionNamesPsResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetPartitionNamesPsResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetPartitionNamesPsResponse &a, GetPartitionNamesPsResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetPartitionNamesPsResponse& obj); + +typedef struct _GetPartitionsPsWithAuthRequest__isset { + _GetPartitionsPsWithAuthRequest__isset() : catName(false), partVals(false), maxParts(true), userName(false), groupNames(false), validWriteIdList(false), id(true), skipColumnSchemaForPartition(false), includeParamKeyPattern(false), excludeParamKeyPattern(false), partNames(false) {} + bool catName :1; + bool partVals :1; + bool maxParts :1; + bool userName :1; + bool groupNames :1; + bool validWriteIdList :1; + bool id :1; + bool skipColumnSchemaForPartition :1; + bool includeParamKeyPattern :1; + bool excludeParamKeyPattern :1; + bool partNames :1; +} _GetPartitionsPsWithAuthRequest__isset; + +class GetPartitionsPsWithAuthRequest : public virtual ::apache::thrift::TBase { + public: + + GetPartitionsPsWithAuthRequest(const GetPartitionsPsWithAuthRequest&); + GetPartitionsPsWithAuthRequest& operator=(const GetPartitionsPsWithAuthRequest&); + GetPartitionsPsWithAuthRequest() noexcept; + + virtual ~GetPartitionsPsWithAuthRequest() noexcept; + std::string catName; + std::string dbName; + std::string tblName; + std::vector partVals; + int16_t maxParts; + std::string userName; + std::vector groupNames; + std::string validWriteIdList; + int64_t id; + bool skipColumnSchemaForPartition; + std::string includeParamKeyPattern; + std::string excludeParamKeyPattern; + std::vector partNames; + + _GetPartitionsPsWithAuthRequest__isset __isset; + + void __set_catName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_tblName(const std::string& val); + + void __set_partVals(const std::vector & val); + + void __set_maxParts(const int16_t val); + + void __set_userName(const std::string& val); + + void __set_groupNames(const std::vector & val); + + void __set_validWriteIdList(const std::string& val); + + void __set_id(const int64_t val); + + void __set_skipColumnSchemaForPartition(const bool val); + + void __set_includeParamKeyPattern(const std::string& val); + + void __set_excludeParamKeyPattern(const std::string& val); + + void __set_partNames(const std::vector & val); + + bool operator == (const GetPartitionsPsWithAuthRequest & rhs) const; + bool operator != (const GetPartitionsPsWithAuthRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetPartitionsPsWithAuthRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetPartitionsPsWithAuthRequest &a, GetPartitionsPsWithAuthRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetPartitionsPsWithAuthRequest& obj); + + +class GetPartitionsPsWithAuthResponse : public virtual ::apache::thrift::TBase { + public: + + GetPartitionsPsWithAuthResponse(const GetPartitionsPsWithAuthResponse&); + GetPartitionsPsWithAuthResponse& operator=(const GetPartitionsPsWithAuthResponse&); + GetPartitionsPsWithAuthResponse() noexcept; + + virtual ~GetPartitionsPsWithAuthResponse() noexcept; + std::vector partitions; + + void __set_partitions(const std::vector & val); + + bool operator == (const GetPartitionsPsWithAuthResponse & rhs) const; + bool operator != (const GetPartitionsPsWithAuthResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetPartitionsPsWithAuthResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetPartitionsPsWithAuthResponse &a, GetPartitionsPsWithAuthResponse &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetPartitionsPsWithAuthResponse& obj); + +typedef struct _ReplicationMetrics__isset { + _ReplicationMetrics__isset() : metadata(false), progress(false), messageFormat(false) {} + bool metadata :1; + bool progress :1; + bool messageFormat :1; +} _ReplicationMetrics__isset; + +class ReplicationMetrics : public virtual ::apache::thrift::TBase { + public: + + ReplicationMetrics(const ReplicationMetrics&); + ReplicationMetrics& operator=(const ReplicationMetrics&); + ReplicationMetrics() noexcept; + + virtual ~ReplicationMetrics() noexcept; + int64_t scheduledExecutionId; + std::string policy; + int64_t dumpExecutionId; + std::string metadata; + std::string progress; + std::string messageFormat; + + _ReplicationMetrics__isset __isset; + + void __set_scheduledExecutionId(const int64_t val); + + void __set_policy(const std::string& val); + + void __set_dumpExecutionId(const int64_t val); + + void __set_metadata(const std::string& val); + + void __set_progress(const std::string& val); + + void __set_messageFormat(const std::string& val); + + bool operator == (const ReplicationMetrics & rhs) const; + bool operator != (const ReplicationMetrics &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ReplicationMetrics & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ReplicationMetrics &a, ReplicationMetrics &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ReplicationMetrics& obj); + + +class ReplicationMetricList : public virtual ::apache::thrift::TBase { + public: + + ReplicationMetricList(const ReplicationMetricList&); + ReplicationMetricList& operator=(const ReplicationMetricList&); + ReplicationMetricList() noexcept; + + virtual ~ReplicationMetricList() noexcept; + std::vector replicationMetricList; + + void __set_replicationMetricList(const std::vector & val); + + bool operator == (const ReplicationMetricList & rhs) const; + bool operator != (const ReplicationMetricList &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ReplicationMetricList & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ReplicationMetricList &a, ReplicationMetricList &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ReplicationMetricList& obj); + +typedef struct _GetReplicationMetricsRequest__isset { + _GetReplicationMetricsRequest__isset() : scheduledExecutionId(false), policy(false), dumpExecutionId(false) {} + bool scheduledExecutionId :1; + bool policy :1; + bool dumpExecutionId :1; +} _GetReplicationMetricsRequest__isset; + +class GetReplicationMetricsRequest : public virtual ::apache::thrift::TBase { + public: + + GetReplicationMetricsRequest(const GetReplicationMetricsRequest&); + GetReplicationMetricsRequest& operator=(const GetReplicationMetricsRequest&); + GetReplicationMetricsRequest() noexcept; + + virtual ~GetReplicationMetricsRequest() noexcept; + int64_t scheduledExecutionId; + std::string policy; + int64_t dumpExecutionId; + + _GetReplicationMetricsRequest__isset __isset; + + void __set_scheduledExecutionId(const int64_t val); + + void __set_policy(const std::string& val); + + void __set_dumpExecutionId(const int64_t val); + + bool operator == (const GetReplicationMetricsRequest & rhs) const; + bool operator != (const GetReplicationMetricsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetReplicationMetricsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetReplicationMetricsRequest &a, GetReplicationMetricsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetReplicationMetricsRequest& obj); + +typedef struct _GetOpenTxnsRequest__isset { + _GetOpenTxnsRequest__isset() : excludeTxnTypes(false) {} + bool excludeTxnTypes :1; +} _GetOpenTxnsRequest__isset; + +class GetOpenTxnsRequest : public virtual ::apache::thrift::TBase { + public: + + GetOpenTxnsRequest(const GetOpenTxnsRequest&); + GetOpenTxnsRequest& operator=(const GetOpenTxnsRequest&); + GetOpenTxnsRequest() noexcept; + + virtual ~GetOpenTxnsRequest() noexcept; + std::vector excludeTxnTypes; + + _GetOpenTxnsRequest__isset __isset; + + void __set_excludeTxnTypes(const std::vector & val); + + bool operator == (const GetOpenTxnsRequest & rhs) const; + bool operator != (const GetOpenTxnsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetOpenTxnsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetOpenTxnsRequest &a, GetOpenTxnsRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetOpenTxnsRequest& obj); + + +class StoredProcedureRequest : public virtual ::apache::thrift::TBase { + public: + + StoredProcedureRequest(const StoredProcedureRequest&); + StoredProcedureRequest& operator=(const StoredProcedureRequest&); + StoredProcedureRequest() noexcept; + + virtual ~StoredProcedureRequest() noexcept; + std::string catName; + std::string dbName; + std::string procName; + + void __set_catName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_procName(const std::string& val); + + bool operator == (const StoredProcedureRequest & rhs) const; + bool operator != (const StoredProcedureRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const StoredProcedureRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(StoredProcedureRequest &a, StoredProcedureRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const StoredProcedureRequest& obj); + +typedef struct _ListStoredProcedureRequest__isset { + _ListStoredProcedureRequest__isset() : dbName(false) {} + bool dbName :1; +} _ListStoredProcedureRequest__isset; + +class ListStoredProcedureRequest : public virtual ::apache::thrift::TBase { + public: + + ListStoredProcedureRequest(const ListStoredProcedureRequest&); + ListStoredProcedureRequest& operator=(const ListStoredProcedureRequest&); + ListStoredProcedureRequest() noexcept; + + virtual ~ListStoredProcedureRequest() noexcept; + std::string catName; + std::string dbName; + + _ListStoredProcedureRequest__isset __isset; + + void __set_catName(const std::string& val); + + void __set_dbName(const std::string& val); + + bool operator == (const ListStoredProcedureRequest & rhs) const; + bool operator != (const ListStoredProcedureRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ListStoredProcedureRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ListStoredProcedureRequest &a, ListStoredProcedureRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ListStoredProcedureRequest& obj); + +typedef struct _StoredProcedure__isset { + _StoredProcedure__isset() : name(false), dbName(false), catName(false), ownerName(false), source(false) {} + bool name :1; + bool dbName :1; + bool catName :1; + bool ownerName :1; + bool source :1; +} _StoredProcedure__isset; + +class StoredProcedure : public virtual ::apache::thrift::TBase { + public: + + StoredProcedure(const StoredProcedure&); + StoredProcedure& operator=(const StoredProcedure&); + StoredProcedure() noexcept; + + virtual ~StoredProcedure() noexcept; + std::string name; + std::string dbName; + std::string catName; + std::string ownerName; + std::string source; + + _StoredProcedure__isset __isset; + + void __set_name(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_catName(const std::string& val); + + void __set_ownerName(const std::string& val); + + void __set_source(const std::string& val); + + bool operator == (const StoredProcedure & rhs) const; + bool operator != (const StoredProcedure &rhs) const { + return !(*this == rhs); + } + + bool operator < (const StoredProcedure & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(StoredProcedure &a, StoredProcedure &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const StoredProcedure& obj); + +typedef struct _AddPackageRequest__isset { + _AddPackageRequest__isset() : catName(false), dbName(false), packageName(false), ownerName(false), header(false), body(false) {} + bool catName :1; + bool dbName :1; + bool packageName :1; + bool ownerName :1; + bool header :1; + bool body :1; +} _AddPackageRequest__isset; + +class AddPackageRequest : public virtual ::apache::thrift::TBase { + public: + + AddPackageRequest(const AddPackageRequest&); + AddPackageRequest& operator=(const AddPackageRequest&); + AddPackageRequest() noexcept; + + virtual ~AddPackageRequest() noexcept; + std::string catName; + std::string dbName; + std::string packageName; + std::string ownerName; + std::string header; + std::string body; + + _AddPackageRequest__isset __isset; + + void __set_catName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_packageName(const std::string& val); + + void __set_ownerName(const std::string& val); + + void __set_header(const std::string& val); + + void __set_body(const std::string& val); + + bool operator == (const AddPackageRequest & rhs) const; + bool operator != (const AddPackageRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AddPackageRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AddPackageRequest &a, AddPackageRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AddPackageRequest& obj); + + +class GetPackageRequest : public virtual ::apache::thrift::TBase { + public: + + GetPackageRequest(const GetPackageRequest&); + GetPackageRequest& operator=(const GetPackageRequest&); + GetPackageRequest() noexcept; + + virtual ~GetPackageRequest() noexcept; + std::string catName; + std::string dbName; + std::string packageName; + + void __set_catName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_packageName(const std::string& val); + + bool operator == (const GetPackageRequest & rhs) const; + bool operator != (const GetPackageRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetPackageRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetPackageRequest &a, GetPackageRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetPackageRequest& obj); + + +class DropPackageRequest : public virtual ::apache::thrift::TBase { + public: + + DropPackageRequest(const DropPackageRequest&); + DropPackageRequest& operator=(const DropPackageRequest&); + DropPackageRequest() noexcept; + + virtual ~DropPackageRequest() noexcept; + std::string catName; + std::string dbName; + std::string packageName; + + void __set_catName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_packageName(const std::string& val); + + bool operator == (const DropPackageRequest & rhs) const; + bool operator != (const DropPackageRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const DropPackageRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(DropPackageRequest &a, DropPackageRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const DropPackageRequest& obj); + +typedef struct _ListPackageRequest__isset { + _ListPackageRequest__isset() : dbName(false) {} + bool dbName :1; +} _ListPackageRequest__isset; + +class ListPackageRequest : public virtual ::apache::thrift::TBase { + public: + + ListPackageRequest(const ListPackageRequest&); + ListPackageRequest& operator=(const ListPackageRequest&); + ListPackageRequest() noexcept; + + virtual ~ListPackageRequest() noexcept; + std::string catName; + std::string dbName; + + _ListPackageRequest__isset __isset; + + void __set_catName(const std::string& val); + + void __set_dbName(const std::string& val); + + bool operator == (const ListPackageRequest & rhs) const; + bool operator != (const ListPackageRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ListPackageRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ListPackageRequest &a, ListPackageRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ListPackageRequest& obj); + +typedef struct _Package__isset { + _Package__isset() : catName(false), dbName(false), packageName(false), ownerName(false), header(false), body(false) {} + bool catName :1; + bool dbName :1; + bool packageName :1; + bool ownerName :1; + bool header :1; + bool body :1; +} _Package__isset; + +class Package : public virtual ::apache::thrift::TBase { + public: + + Package(const Package&); + Package& operator=(const Package&); + Package() noexcept; + + virtual ~Package() noexcept; + std::string catName; + std::string dbName; + std::string packageName; + std::string ownerName; + std::string header; + std::string body; + + _Package__isset __isset; + + void __set_catName(const std::string& val); + + void __set_dbName(const std::string& val); + + void __set_packageName(const std::string& val); + + void __set_ownerName(const std::string& val); + + void __set_header(const std::string& val); + + void __set_body(const std::string& val); + + bool operator == (const Package & rhs) const; + bool operator != (const Package &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Package & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Package &a, Package &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const Package& obj); + +typedef struct _GetAllWriteEventInfoRequest__isset { + _GetAllWriteEventInfoRequest__isset() : dbName(false), tableName(false) {} + bool dbName :1; + bool tableName :1; +} _GetAllWriteEventInfoRequest__isset; + +class GetAllWriteEventInfoRequest : public virtual ::apache::thrift::TBase { + public: + + GetAllWriteEventInfoRequest(const GetAllWriteEventInfoRequest&); + GetAllWriteEventInfoRequest& operator=(const GetAllWriteEventInfoRequest&); + GetAllWriteEventInfoRequest() noexcept; + + virtual ~GetAllWriteEventInfoRequest() noexcept; + int64_t txnId; + std::string dbName; + std::string tableName; + + _GetAllWriteEventInfoRequest__isset __isset; + + void __set_txnId(const int64_t val); + + void __set_dbName(const std::string& val); + + void __set_tableName(const std::string& val); + + bool operator == (const GetAllWriteEventInfoRequest & rhs) const; + bool operator != (const GetAllWriteEventInfoRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetAllWriteEventInfoRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetAllWriteEventInfoRequest &a, GetAllWriteEventInfoRequest &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const GetAllWriteEventInfoRequest& obj); + +typedef struct _MetaException__isset { + _MetaException__isset() : message(false) {} + bool message :1; +} _MetaException__isset; + +class MetaException : public ::apache::thrift::TException { + public: + + MetaException(const MetaException&); + MetaException& operator=(const MetaException&); + MetaException() noexcept; + + virtual ~MetaException() noexcept; + std::string message; + + _MetaException__isset __isset; + + void __set_message(const std::string& val); + + bool operator == (const MetaException & rhs) const; + bool operator != (const MetaException &rhs) const { + return !(*this == rhs); + } + + bool operator < (const MetaException & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; + mutable std::string thriftTExceptionMessageHolder_; + const char* what() const noexcept override; +}; + +void swap(MetaException &a, MetaException &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const MetaException& obj); + +typedef struct _UnknownTableException__isset { + _UnknownTableException__isset() : message(false) {} + bool message :1; +} _UnknownTableException__isset; + +class UnknownTableException : public ::apache::thrift::TException { + public: + + UnknownTableException(const UnknownTableException&); + UnknownTableException& operator=(const UnknownTableException&); + UnknownTableException() noexcept; + + virtual ~UnknownTableException() noexcept; + std::string message; + + _UnknownTableException__isset __isset; + + void __set_message(const std::string& val); + + bool operator == (const UnknownTableException & rhs) const; + bool operator != (const UnknownTableException &rhs) const { + return !(*this == rhs); + } + + bool operator < (const UnknownTableException & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; + mutable std::string thriftTExceptionMessageHolder_; + const char* what() const noexcept override; +}; + +void swap(UnknownTableException &a, UnknownTableException &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const UnknownTableException& obj); + +typedef struct _UnknownDBException__isset { + _UnknownDBException__isset() : message(false) {} + bool message :1; +} _UnknownDBException__isset; + +class UnknownDBException : public ::apache::thrift::TException { + public: + + UnknownDBException(const UnknownDBException&); + UnknownDBException& operator=(const UnknownDBException&); + UnknownDBException() noexcept; + + virtual ~UnknownDBException() noexcept; + std::string message; + + _UnknownDBException__isset __isset; + + void __set_message(const std::string& val); + + bool operator == (const UnknownDBException & rhs) const; + bool operator != (const UnknownDBException &rhs) const { + return !(*this == rhs); + } + + bool operator < (const UnknownDBException & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; + mutable std::string thriftTExceptionMessageHolder_; + const char* what() const noexcept override; +}; + +void swap(UnknownDBException &a, UnknownDBException &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const UnknownDBException& obj); + +typedef struct _AlreadyExistsException__isset { + _AlreadyExistsException__isset() : message(false) {} + bool message :1; +} _AlreadyExistsException__isset; + +class AlreadyExistsException : public ::apache::thrift::TException { + public: + + AlreadyExistsException(const AlreadyExistsException&); + AlreadyExistsException& operator=(const AlreadyExistsException&); + AlreadyExistsException() noexcept; + + virtual ~AlreadyExistsException() noexcept; + std::string message; + + _AlreadyExistsException__isset __isset; + + void __set_message(const std::string& val); + + bool operator == (const AlreadyExistsException & rhs) const; + bool operator != (const AlreadyExistsException &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AlreadyExistsException & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; + mutable std::string thriftTExceptionMessageHolder_; + const char* what() const noexcept override; +}; + +void swap(AlreadyExistsException &a, AlreadyExistsException &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const AlreadyExistsException& obj); + +typedef struct _InvalidPartitionException__isset { + _InvalidPartitionException__isset() : message(false) {} + bool message :1; +} _InvalidPartitionException__isset; + +class InvalidPartitionException : public ::apache::thrift::TException { + public: + + InvalidPartitionException(const InvalidPartitionException&); + InvalidPartitionException& operator=(const InvalidPartitionException&); + InvalidPartitionException() noexcept; + + virtual ~InvalidPartitionException() noexcept; + std::string message; + + _InvalidPartitionException__isset __isset; + + void __set_message(const std::string& val); + + bool operator == (const InvalidPartitionException & rhs) const; + bool operator != (const InvalidPartitionException &rhs) const { + return !(*this == rhs); + } + + bool operator < (const InvalidPartitionException & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; + mutable std::string thriftTExceptionMessageHolder_; + const char* what() const noexcept override; +}; + +void swap(InvalidPartitionException &a, InvalidPartitionException &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const InvalidPartitionException& obj); + +typedef struct _UnknownPartitionException__isset { + _UnknownPartitionException__isset() : message(false) {} + bool message :1; +} _UnknownPartitionException__isset; + +class UnknownPartitionException : public ::apache::thrift::TException { + public: + + UnknownPartitionException(const UnknownPartitionException&); + UnknownPartitionException& operator=(const UnknownPartitionException&); + UnknownPartitionException() noexcept; + + virtual ~UnknownPartitionException() noexcept; + std::string message; + + _UnknownPartitionException__isset __isset; + + void __set_message(const std::string& val); + + bool operator == (const UnknownPartitionException & rhs) const; + bool operator != (const UnknownPartitionException &rhs) const { + return !(*this == rhs); + } + + bool operator < (const UnknownPartitionException & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; + mutable std::string thriftTExceptionMessageHolder_; + const char* what() const noexcept override; +}; + +void swap(UnknownPartitionException &a, UnknownPartitionException &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const UnknownPartitionException& obj); + +typedef struct _InvalidObjectException__isset { + _InvalidObjectException__isset() : message(false) {} + bool message :1; +} _InvalidObjectException__isset; + +class InvalidObjectException : public ::apache::thrift::TException { + public: + + InvalidObjectException(const InvalidObjectException&); + InvalidObjectException& operator=(const InvalidObjectException&); + InvalidObjectException() noexcept; + + virtual ~InvalidObjectException() noexcept; + std::string message; + + _InvalidObjectException__isset __isset; + + void __set_message(const std::string& val); + + bool operator == (const InvalidObjectException & rhs) const; + bool operator != (const InvalidObjectException &rhs) const { + return !(*this == rhs); + } + + bool operator < (const InvalidObjectException & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; + mutable std::string thriftTExceptionMessageHolder_; + const char* what() const noexcept override; +}; + +void swap(InvalidObjectException &a, InvalidObjectException &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const InvalidObjectException& obj); + +typedef struct _NoSuchObjectException__isset { + _NoSuchObjectException__isset() : message(false) {} + bool message :1; +} _NoSuchObjectException__isset; + +class NoSuchObjectException : public ::apache::thrift::TException { + public: + + NoSuchObjectException(const NoSuchObjectException&); + NoSuchObjectException& operator=(const NoSuchObjectException&); + NoSuchObjectException() noexcept; + + virtual ~NoSuchObjectException() noexcept; + std::string message; + + _NoSuchObjectException__isset __isset; + + void __set_message(const std::string& val); + + bool operator == (const NoSuchObjectException & rhs) const; + bool operator != (const NoSuchObjectException &rhs) const { + return !(*this == rhs); + } + + bool operator < (const NoSuchObjectException & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; + mutable std::string thriftTExceptionMessageHolder_; + const char* what() const noexcept override; +}; + +void swap(NoSuchObjectException &a, NoSuchObjectException &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const NoSuchObjectException& obj); + +typedef struct _InvalidOperationException__isset { + _InvalidOperationException__isset() : message(false) {} + bool message :1; +} _InvalidOperationException__isset; + +class InvalidOperationException : public ::apache::thrift::TException { + public: + + InvalidOperationException(const InvalidOperationException&); + InvalidOperationException& operator=(const InvalidOperationException&); + InvalidOperationException() noexcept; + + virtual ~InvalidOperationException() noexcept; + std::string message; + + _InvalidOperationException__isset __isset; + + void __set_message(const std::string& val); + + bool operator == (const InvalidOperationException & rhs) const; + bool operator != (const InvalidOperationException &rhs) const { + return !(*this == rhs); + } + + bool operator < (const InvalidOperationException & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; + mutable std::string thriftTExceptionMessageHolder_; + const char* what() const noexcept override; +}; + +void swap(InvalidOperationException &a, InvalidOperationException &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const InvalidOperationException& obj); + +typedef struct _ConfigValSecurityException__isset { + _ConfigValSecurityException__isset() : message(false) {} + bool message :1; +} _ConfigValSecurityException__isset; + +class ConfigValSecurityException : public ::apache::thrift::TException { + public: + + ConfigValSecurityException(const ConfigValSecurityException&); + ConfigValSecurityException& operator=(const ConfigValSecurityException&); + ConfigValSecurityException() noexcept; + + virtual ~ConfigValSecurityException() noexcept; + std::string message; + + _ConfigValSecurityException__isset __isset; + + void __set_message(const std::string& val); + + bool operator == (const ConfigValSecurityException & rhs) const; + bool operator != (const ConfigValSecurityException &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ConfigValSecurityException & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; + mutable std::string thriftTExceptionMessageHolder_; + const char* what() const noexcept override; +}; + +void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const ConfigValSecurityException& obj); + +typedef struct _InvalidInputException__isset { + _InvalidInputException__isset() : message(false) {} + bool message :1; +} _InvalidInputException__isset; + +class InvalidInputException : public ::apache::thrift::TException { + public: + + InvalidInputException(const InvalidInputException&); + InvalidInputException& operator=(const InvalidInputException&); + InvalidInputException() noexcept; + + virtual ~InvalidInputException() noexcept; + std::string message; + + _InvalidInputException__isset __isset; + + void __set_message(const std::string& val); + + bool operator == (const InvalidInputException & rhs) const; + bool operator != (const InvalidInputException &rhs) const { + return !(*this == rhs); + } + + bool operator < (const InvalidInputException & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; + mutable std::string thriftTExceptionMessageHolder_; + const char* what() const noexcept override; +}; + +void swap(InvalidInputException &a, InvalidInputException &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const InvalidInputException& obj); + +typedef struct _NoSuchTxnException__isset { + _NoSuchTxnException__isset() : message(false) {} + bool message :1; +} _NoSuchTxnException__isset; + +class NoSuchTxnException : public ::apache::thrift::TException { + public: + + NoSuchTxnException(const NoSuchTxnException&); + NoSuchTxnException& operator=(const NoSuchTxnException&); + NoSuchTxnException() noexcept; + + virtual ~NoSuchTxnException() noexcept; + std::string message; + + _NoSuchTxnException__isset __isset; + + void __set_message(const std::string& val); + + bool operator == (const NoSuchTxnException & rhs) const; + bool operator != (const NoSuchTxnException &rhs) const { + return !(*this == rhs); + } + + bool operator < (const NoSuchTxnException & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; + mutable std::string thriftTExceptionMessageHolder_; + const char* what() const noexcept override; +}; + +void swap(NoSuchTxnException &a, NoSuchTxnException &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const NoSuchTxnException& obj); + +typedef struct _TxnAbortedException__isset { + _TxnAbortedException__isset() : message(false) {} + bool message :1; +} _TxnAbortedException__isset; + +class TxnAbortedException : public ::apache::thrift::TException { + public: + + TxnAbortedException(const TxnAbortedException&); + TxnAbortedException& operator=(const TxnAbortedException&); + TxnAbortedException() noexcept; + + virtual ~TxnAbortedException() noexcept; + std::string message; + + _TxnAbortedException__isset __isset; + + void __set_message(const std::string& val); + + bool operator == (const TxnAbortedException & rhs) const; + bool operator != (const TxnAbortedException &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TxnAbortedException & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; + mutable std::string thriftTExceptionMessageHolder_; + const char* what() const noexcept override; +}; + +void swap(TxnAbortedException &a, TxnAbortedException &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const TxnAbortedException& obj); + +typedef struct _TxnOpenException__isset { + _TxnOpenException__isset() : message(false) {} + bool message :1; +} _TxnOpenException__isset; + +class TxnOpenException : public ::apache::thrift::TException { + public: + + TxnOpenException(const TxnOpenException&); + TxnOpenException& operator=(const TxnOpenException&); + TxnOpenException() noexcept; + + virtual ~TxnOpenException() noexcept; + std::string message; + + _TxnOpenException__isset __isset; + + void __set_message(const std::string& val); + + bool operator == (const TxnOpenException & rhs) const; + bool operator != (const TxnOpenException &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TxnOpenException & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; + mutable std::string thriftTExceptionMessageHolder_; + const char* what() const noexcept override; +}; + +void swap(TxnOpenException &a, TxnOpenException &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const TxnOpenException& obj); + +typedef struct _NoSuchLockException__isset { + _NoSuchLockException__isset() : message(false) {} + bool message :1; +} _NoSuchLockException__isset; + +class NoSuchLockException : public ::apache::thrift::TException { + public: + + NoSuchLockException(const NoSuchLockException&); + NoSuchLockException& operator=(const NoSuchLockException&); + NoSuchLockException() noexcept; + + virtual ~NoSuchLockException() noexcept; + std::string message; + + _NoSuchLockException__isset __isset; + + void __set_message(const std::string& val); + + bool operator == (const NoSuchLockException & rhs) const; + bool operator != (const NoSuchLockException &rhs) const { + return !(*this == rhs); + } + + bool operator < (const NoSuchLockException & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; + mutable std::string thriftTExceptionMessageHolder_; + const char* what() const noexcept override; +}; + +void swap(NoSuchLockException &a, NoSuchLockException &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const NoSuchLockException& obj); + +typedef struct _CompactionAbortedException__isset { + _CompactionAbortedException__isset() : message(false) {} + bool message :1; +} _CompactionAbortedException__isset; + +class CompactionAbortedException : public ::apache::thrift::TException { + public: + + CompactionAbortedException(const CompactionAbortedException&); + CompactionAbortedException& operator=(const CompactionAbortedException&); + CompactionAbortedException() noexcept; + + virtual ~CompactionAbortedException() noexcept; + std::string message; + + _CompactionAbortedException__isset __isset; + + void __set_message(const std::string& val); + + bool operator == (const CompactionAbortedException & rhs) const; + bool operator != (const CompactionAbortedException &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CompactionAbortedException & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; + mutable std::string thriftTExceptionMessageHolder_; + const char* what() const noexcept override; +}; + +void swap(CompactionAbortedException &a, CompactionAbortedException &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const CompactionAbortedException& obj); + +typedef struct _NoSuchCompactionException__isset { + _NoSuchCompactionException__isset() : message(false) {} + bool message :1; +} _NoSuchCompactionException__isset; + +class NoSuchCompactionException : public ::apache::thrift::TException { + public: + + NoSuchCompactionException(const NoSuchCompactionException&); + NoSuchCompactionException& operator=(const NoSuchCompactionException&); + NoSuchCompactionException() noexcept; + + virtual ~NoSuchCompactionException() noexcept; + std::string message; + + _NoSuchCompactionException__isset __isset; + + void __set_message(const std::string& val); + + bool operator == (const NoSuchCompactionException & rhs) const; + bool operator != (const NoSuchCompactionException &rhs) const { + return !(*this == rhs); + } + + bool operator < (const NoSuchCompactionException & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; + mutable std::string thriftTExceptionMessageHolder_; + const char* what() const noexcept override; +}; + +void swap(NoSuchCompactionException &a, NoSuchCompactionException &b) noexcept; + +std::ostream& operator<<(std::ostream& out, const NoSuchCompactionException& obj); + +}}} // namespace + +#endif diff --git a/thirdparty/hive_metastore/README.md b/thirdparty/hive_metastore/README.md index 9865e4655..96839d9a3 100644 --- a/thirdparty/hive_metastore/README.md +++ b/thirdparty/hive_metastore/README.md @@ -34,7 +34,7 @@ is reproducible and future updates are deterministic. | File | Upstream | Tag | Commit | | --- | --- | --- | --- | -| `hive_metastore.thrift` | [apache/hive](https://github.com/apache/hive) — `standalone-metastore/src/main/thrift/hive_metastore.thrift` | `rel/release-3.1.3` | [`04c1b307d1bbd1ae268ad47dc36ca4f50c6d9cd8`](https://github.com/apache/hive/blob/04c1b307d1bbd1ae268ad47dc36ca4f50c6d9cd8/standalone-metastore/src/main/thrift/hive_metastore.thrift) | +| `hive_metastore.thrift` | [apache/hive](https://github.com/apache/hive) — `standalone-metastore/metastore-common/src/main/thrift/hive_metastore.thrift` | `rel/release-4.0.1` | [`d4c36d45eb3b23abf17d9a9848371a145291ffd4`](https://github.com/apache/hive/blob/d4c36d45eb3b23abf17d9a9848371a145291ffd4/standalone-metastore/metastore-common/src/main/thrift/hive_metastore.thrift) | | `share/fb303/if/fb303.thrift` | [apache/thrift](https://github.com/apache/thrift) — `contrib/fb303/if/fb303.thrift` | `v0.14.0` | [`8411e189b0af09e5baad34031555870cf692c1ad`](https://github.com/apache/thrift/blob/8411e189b0af09e5baad34031555870cf692c1ad/contrib/fb303/if/fb303.thrift) | `fb303.thrift` is the Facebook fb303 management service IDL, transitively diff --git a/thirdparty/hive_metastore/hive_metastore.thrift b/thirdparty/hive_metastore/hive_metastore.thrift index 97344d9e1..f292b210f 100644 --- a/thirdparty/hive_metastore/hive_metastore.thrift +++ b/thirdparty/hive_metastore/hive_metastore.thrift @@ -29,6 +29,10 @@ namespace php metastore namespace cpp Apache.Hadoop.Hive const string DDL_TIME = "transient_lastDdlTime" +const byte ACCESSTYPE_NONE = 1; +const byte ACCESSTYPE_READONLY = 2; +const byte ACCESSTYPE_WRITEONLY = 4; +const byte ACCESSTYPE_READWRITE = 8; struct Version { 1: string version, @@ -41,6 +45,14 @@ struct FieldSchema { 3: string comment } +// Key-value store to be used with selected +// Metastore APIs (create, alter methods). +// The client can pass environment properties / configs that can be +// accessed in hooks. +struct EnvironmentContext { + 1: map properties +} + struct SQLPrimaryKey { 1: string table_db, // table schema 2: string table_name, // table name @@ -118,6 +130,15 @@ struct SQLCheckConstraint { 9: bool rely_cstr // Rely/No Rely } +struct SQLAllTableConstraints { + 1: optional list primaryKeys, + 2: optional list foreignKeys, + 3: optional list uniqueConstraints, + 4: optional list notNullConstraints, + 5: optional list defaultConstraints, + 6: optional list checkConstraints +} + struct Type { 1: string name, // one of the types in PrimitiveTypes or CollectionTypes or User defined types 2: optional string type1, // object type if the name is 'list' (LIST_TYPE), key type if the name is 'map' (MAP_TYPE) @@ -131,6 +152,7 @@ enum HiveObjectType { TABLE = 3, PARTITION = 4, COLUMN = 5, + DATACONNECTOR = 6, } enum PrincipalType { @@ -142,6 +164,24 @@ enum PrincipalType { const string HIVE_FILTER_FIELD_OWNER = "hive_filter_field_owner__" const string HIVE_FILTER_FIELD_PARAMS = "hive_filter_field_params__" const string HIVE_FILTER_FIELD_LAST_ACCESS = "hive_filter_field_last_access__" +const string HIVE_FILTER_FIELD_TABLE_NAME = "hive_filter_field_tableName__" +const string HIVE_FILTER_FIELD_TABLE_TYPE = "hive_filter_field_tableType__" + +struct PropertySetRequest { + 1: required string nameSpace; + 2: map propertyMap; +} + +struct PropertyGetRequest { + 1: required string nameSpace; + 2: string mapPrefix; + 3: optional string mapPredicate; + 4: optional list mapSelection; +} + +struct PropertyGetResponse { + 1: map> properties; +} enum PartitionEventType { LOAD_DONE = 1, @@ -171,11 +211,14 @@ enum LockType { SHARED_READ = 1, SHARED_WRITE = 2, EXCLUSIVE = 3, + EXCL_WRITE = 4, } enum CompactionType { MINOR = 1, MAJOR = 2, + REBALANCE = 3, + ABORT_TXN_CLEANUP = 4, } enum GrantRevokeType { @@ -233,6 +276,11 @@ enum SchemaVersionState { DELETED = 8 } +enum DatabaseType { + NATIVE = 1, + REMOTE = 2 +} + struct HiveObjectRef{ 1: HiveObjectType objectType, 2: string dbName, @@ -278,6 +326,18 @@ struct GrantRevokePrivilegeResponse { 1: optional bool success; } +struct TruncateTableRequest { + 1: required string dbName, + 2: required string tableName, + 3: optional list partNames, + 4: optional i64 writeId=-1, + 5: optional string validWriteIdList, + 6: optional EnvironmentContext environmentContext +} + +struct TruncateTableResponse { +} + struct Role { 1: string roleName, 2: i32 createTime, @@ -329,9 +389,10 @@ struct GrantRevokeRoleResponse { struct Catalog { 1: string name, // Name of the catalog 2: optional string description, // description of the catalog - 3: string locationUri // default storage location. When databases are created in - // this catalog, if they do not specify a location, they will - // be placed in this location. + 3: string locationUri, // default storage location. When databases are created in + // this catalog, if they do not specify a location, they will + // be placed in this location. + 4: optional i32 createTime // creation time of catalog in seconds since epoch } struct CreateCatalogRequest { @@ -368,7 +429,12 @@ struct Database { 5: optional PrincipalPrivilegeSet privileges, 6: optional string ownerName, 7: optional PrincipalType ownerType, - 8: optional string catalogName + 8: optional string catalogName, + 9: optional i32 createTime, // creation time of database in seconds since epoch + 10: optional string managedLocationUri, // directory for managed tables + 11: optional DatabaseType type, + 12: optional string connector_name, + 13: optional string remote_dbname } // This object holds the information needed by SerDes @@ -411,65 +477,14 @@ struct StorageDescriptor { 12: optional bool storedAsSubDirectories // stored as subdirectories or not } -// table information -struct Table { - 1: string tableName, // name of the table - 2: string dbName, // database name ('default') - 3: string owner, // owner of this table - 4: i32 createTime, // creation time of the table - 5: i32 lastAccessTime, // last access time (usually this will be filled from HDFS and shouldn't be relied on) - 6: i32 retention, // retention time - 7: StorageDescriptor sd, // storage descriptor of the table - 8: list partitionKeys, // partition keys of the table. only primitive types are supported - 9: map parameters, // to store comments or any other user level parameters - 10: string viewOriginalText, // original view text, null for non-view - 11: string viewExpandedText, // expanded view text, null for non-view - 12: string tableType, // table type enum, e.g. EXTERNAL_TABLE - 13: optional PrincipalPrivilegeSet privileges, - 14: optional bool temporary=false, - 15: optional bool rewriteEnabled, // rewrite enabled or not - 16: optional CreationMetadata creationMetadata, // only for MVs, it stores table names used and txn list at MV creation - 17: optional string catName, // Name of the catalog the table is in - 18: optional PrincipalType ownerType = PrincipalType.USER // owner type of this table (default to USER for backward compatibility) -} - -struct Partition { - 1: list values // string value is converted to appropriate partition key type - 2: string dbName, - 3: string tableName, - 4: i32 createTime, - 5: i32 lastAccessTime, - 6: StorageDescriptor sd, - 7: map parameters, - 8: optional PrincipalPrivilegeSet privileges, - 9: optional string catName -} - -struct PartitionWithoutSD { - 1: list values // string value is converted to appropriate partition key type - 2: i32 createTime, - 3: i32 lastAccessTime, - 4: string relativePath, - 5: map parameters, - 6: optional PrincipalPrivilegeSet privileges -} - -struct PartitionSpecWithSharedSD { - 1: list partitions, - 2: StorageDescriptor sd, -} - -struct PartitionListComposingSpec { - 1: list partitions -} - -struct PartitionSpec { - 1: string dbName, - 2: string tableName, - 3: string rootPath, - 4: optional PartitionSpecWithSharedSD sharedSDPartitionSpec, - 5: optional PartitionListComposingSpec partitionList, - 6: optional string catName +struct CreationMetadata { + 1: required string catName, + 2: required string dbName, + 3: required string tblName, + 4: required set tablesUsed, + 5: optional string validTxnList, + 6: optional i64 materializationTime, + 7: optional list sourceTables } // column statistics @@ -485,7 +500,8 @@ struct DoubleColumnStatsData { 2: optional double highValue, 3: required i64 numNulls, 4: required i64 numDVs, -5: optional binary bitVectors +5: optional binary bitVectors, +6: optional binary histogram } struct LongColumnStatsData { @@ -493,7 +509,8 @@ struct LongColumnStatsData { 2: optional i64 highValue, 3: required i64 numNulls, 4: required i64 numDVs, -5: optional binary bitVectors +5: optional binary bitVectors, +6: optional binary histogram } struct StringColumnStatsData { @@ -522,7 +539,8 @@ struct DecimalColumnStatsData { 2: optional Decimal highValue, 3: required i64 numNulls, 4: required i64 numDVs, -5: optional binary bitVectors +5: optional binary bitVectors, +6: optional binary histogram } struct Date { @@ -534,7 +552,21 @@ struct DateColumnStatsData { 2: optional Date highValue, 3: required i64 numNulls, 4: required i64 numDVs, -5: optional binary bitVectors +5: optional binary bitVectors, +6: optional binary histogram +} + +struct Timestamp { +1: required i64 secondsSinceEpoch +} + +struct TimestampColumnStatsData { +1: optional Timestamp lowValue, +2: optional Timestamp highValue, +3: required i64 numNulls, +4: required i64 numDVs, +5: optional binary bitVectors, +6: optional binary histogram } union ColumnStatisticsData { @@ -544,7 +576,8 @@ union ColumnStatisticsData { 4: StringColumnStatsData stringStats, 5: BinaryColumnStatsData binaryStats, 6: DecimalColumnStatsData decimalStats, -7: DateColumnStatsData dateStats +7: DateColumnStatsData dateStats, +8: TimestampColumnStatsData timestampStats } struct ColumnStatisticsObj { @@ -564,17 +597,139 @@ struct ColumnStatisticsDesc { struct ColumnStatistics { 1: required ColumnStatisticsDesc statsDesc, -2: required list statsObj; +2: required list statsObj, +3: optional bool isStatsCompliant, // Are the stats isolation-level-compliant with the + // the calling query? +4: optional string engine = "hive" +} + +// FileMetadata represents the table-level (in case of unpartitioned) or partition-level +// file metadata. Each partition could have more than 1 files and hence the list of +// binary data field. Each value in data field corresponds to metadata for one file. +struct FileMetadata { + // current supported type mappings are + // 1 -> IMPALA + 1: byte type = 1 + 2: byte version = 1 + 3: list data +} + +// this field can be used to store repeatitive information +// (like network addresses in filemetadata). Instead of +// sending the same object repeatedly, we can send the indices +// corresponding to the object in this list. +struct ObjectDictionary { + // the key can be used to determine the object type + // the value is the list of the objects which can be accessed + // using their indices. These indices can be used to send instead of + // full object which can reduce the payload significantly in case of + // repetitive objects. + 1: required map> values +} + +// table information +struct Table { + 1: string tableName, // name of the table + 2: string dbName, // database name ('default') + 3: string owner, // owner of this table + 4: i32 createTime, // creation time of the table + 5: i32 lastAccessTime, // last access time (usually this will be filled from HDFS and shouldn't be relied on) + 6: i32 retention, // retention time + 7: StorageDescriptor sd, // storage descriptor of the table + 8: list partitionKeys, // partition keys of the table. only primitive types are supported + 9: map parameters, // to store comments or any other user level parameters + 10: string viewOriginalText, // original view text, null for non-view + 11: string viewExpandedText, // expanded view text, null for non-view + 12: string tableType, // table type enum, e.g. EXTERNAL_TABLE + 13: optional PrincipalPrivilegeSet privileges, + 14: optional bool temporary=false, + 15: optional bool rewriteEnabled, // rewrite enabled or not + 16: optional CreationMetadata creationMetadata, // only for MVs, it stores table names used and txn list at MV creation + 17: optional string catName, // Name of the catalog the table is in + 18: optional PrincipalType ownerType = PrincipalType.USER, // owner type of this table (default to USER for backward compatibility) + 19: optional i64 writeId=-1, + 20: optional bool isStatsCompliant, + 21: optional ColumnStatistics colStats, // column statistics for table + 22: optional byte accessType, + 23: optional list requiredReadCapabilities, + 24: optional list requiredWriteCapabilities + 25: optional i64 id, // id of the table. It will be ignored if set. It's only for + // read purposes + 26: optional FileMetadata fileMetadata, // optional serialized file-metadata for this table + // for certain execution engines + 27: optional ObjectDictionary dictionary, + 28: optional i64 txnId, // txnId associated with the table creation +} + +struct SourceTable { + 1: required Table table, + 2: required i64 insertedCount, + 3: required i64 updatedCount, + 4: required i64 deletedCount +} + +struct Partition { + 1: list values // string value is converted to appropriate partition key type + 2: string dbName, + 3: string tableName, + 4: i32 createTime, + 5: i32 lastAccessTime, + 6: StorageDescriptor sd, + 7: map parameters, + 8: optional PrincipalPrivilegeSet privileges, + 9: optional string catName, + 10: optional i64 writeId=-1, + 11: optional bool isStatsCompliant, + 12: optional ColumnStatistics colStats, // column statistics for partition + 13: optional FileMetadata fileMetadata // optional serialized file-metadata useful for certain execution engines +} + +struct PartitionWithoutSD { + 1: list values // string value is converted to appropriate partition key type + 2: i32 createTime, + 3: i32 lastAccessTime, + 4: string relativePath, + 5: map parameters, + 6: optional PrincipalPrivilegeSet privileges +} + +struct PartitionSpecWithSharedSD { + 1: list partitions, + 2: StorageDescriptor sd, +} + + +struct PartitionListComposingSpec { + 1: list partitions +} + +struct PartitionSpec { + 1: string dbName, + 2: string tableName, + 3: string rootPath, + 4: optional PartitionSpecWithSharedSD sharedSDPartitionSpec, + 5: optional PartitionListComposingSpec partitionList, + 6: optional string catName, + 7: optional i64 writeId=-1, + 8: optional bool isStatsCompliant } struct AggrStats { 1: required list colStats, -2: required i64 partsFound // number of partitions for which stats were found +2: required i64 partsFound, // number of partitions for which stats were found +3: optional bool isStatsCompliant } struct SetPartitionsStatsRequest { 1: required list colStats, -2: optional bool needMerge //stats need to be merged with the existing stats +2: optional bool needMerge, //stats need to be merged with the existing stats +3: optional i64 writeId=-1, // writeId for the current query that updates the stats +4: optional string validWriteIdList, // valid write id list for the table for which this struct is being sent +5: optional string engine = "hive" //engine creating the current request +} + +struct SetPartitionsStatsResponse { +1: required bool result; } // schema of the table/query results etc. @@ -584,18 +739,12 @@ struct Schema { 2: map properties } -// Key-value store to be used with selected -// Metastore APIs (create, alter methods). -// The client can pass environment properties / configs that can be -// accessed in hooks. -struct EnvironmentContext { - 1: map properties -} - struct PrimaryKeysRequest { 1: required string db_name, 2: required string tbl_name, - 3: optional string catName + 3: optional string catName, + 4: optional string validWriteIdList, + 5: optional i64 tableId=-1 } struct PrimaryKeysResponse { @@ -606,8 +755,10 @@ struct ForeignKeysRequest { 1: string parent_db_name, 2: string parent_tbl_name, 3: string foreign_db_name, - 4: string foreign_tbl_name - 5: optional string catName // No cross catalog constraints + 4: string foreign_tbl_name, + 5: optional string catName, // No cross catalog constraints + 6: optional string validWriteIdList, + 7: optional i64 tableId=-1 } struct ForeignKeysResponse { @@ -618,6 +769,8 @@ struct UniqueConstraintsRequest { 1: required string catName, 2: required string db_name, 3: required string tbl_name, + 4: optional string validWriteIdList, + 5: optional i64 tableId=-1 } struct UniqueConstraintsResponse { @@ -628,6 +781,8 @@ struct NotNullConstraintsRequest { 1: required string catName, 2: required string db_name, 3: required string tbl_name, + 4: optional string validWriteIdList, + 5: optional i64 tableId=-1 } struct NotNullConstraintsResponse { @@ -637,7 +792,9 @@ struct NotNullConstraintsResponse { struct DefaultConstraintsRequest { 1: required string catName, 2: required string db_name, - 3: required string tbl_name + 3: required string tbl_name, + 4: optional string validWriteIdList, + 5: optional i64 tableId=-1 } struct DefaultConstraintsResponse { @@ -647,13 +804,26 @@ struct DefaultConstraintsResponse { struct CheckConstraintsRequest { 1: required string catName, 2: required string db_name, - 3: required string tbl_name + 3: required string tbl_name, + 4: optional string validWriteIdList, + 5: optional i64 tableId=-1 } struct CheckConstraintsResponse { 1: required list checkConstraints } +struct AllTableConstraintsRequest { + 1: required string dbName, + 2: required string tblName, + 3: required string catName, + 4: optional string validWriteIdList, + 5: optional i64 tableId=-1 +} + +struct AllTableConstraintsResponse { + 1: required SQLAllTableConstraints allTableConstraints +} struct DropConstraintRequest { 1: required string dbname, @@ -693,28 +863,46 @@ struct PartitionsByExprResult { 2: required bool hasUnknownPartitions } +// Return type for get_partitions_spec_by_expr +struct PartitionsSpecByExprResult { +1: required list partitionsSpec, +// Whether the results has any (currently, all) partitions which may or may not match +2: required bool hasUnknownPartitions +} + struct PartitionsByExprRequest { 1: required string dbName, 2: required string tblName, 3: required binary expr, 4: optional string defaultPartitionName, - 5: optional i16 maxParts=-1 - 6: optional string catName + 5: optional i16 maxParts=-1, + 6: optional string catName, + 7: optional string order + 8: optional string validWriteIdList, + 9: optional i64 id=-1, // table id + 10: optional bool skipColumnSchemaForPartition, + 11: optional string includeParamKeyPattern, + 12: optional string excludeParamKeyPattern } struct TableStatsResult { - 1: required list tableStats + 1: required list tableStats, + 2: optional bool isStatsCompliant } struct PartitionsStatsResult { - 1: required map> partStats + 1: required map> partStats, + 2: optional bool isStatsCompliant } struct TableStatsRequest { 1: required string dbName, 2: required string tblName, 3: required list colNames - 4: optional string catName + 4: optional string catName, + 5: optional string validWriteIdList, // valid write id list for the table for which this struct is being sent + 6: optional string engine = "hive", //engine creating the current request + 7: optional i64 id=-1 // table id } struct PartitionsStatsRequest { @@ -722,12 +910,16 @@ struct PartitionsStatsRequest { 2: required string tblName, 3: required list colNames, 4: required list partNames, - 5: optional string catName + 5: optional string catName, + 6: optional string validWriteIdList, // valid write id list for the table for which this struct is being sent + 7: optional string engine = "hive" //engine creating the current request } // Return type for add_partitions_req struct AddPartitionsResult { 1: optional list partitions, + 2: optional bool isStatsCompliant, + 3: optional list partitionColSchema } // Request type for add_partitions_req @@ -737,7 +929,11 @@ struct AddPartitionsRequest { 3: required list parts, 4: required bool ifNotExists, 5: optional bool needResult=true, - 6: optional string catName + 6: optional string catName, + 7: optional string validWriteIdList, + 8: optional bool skipColumnSchemaForPartition, + 9: optional list partitionColSchema, + 10: optional EnvironmentContext environmentContext } // Return type for drop_partitions_req @@ -766,7 +962,18 @@ struct DropPartitionsRequest { 6: optional bool ignoreProtection, 7: optional EnvironmentContext environmentContext, 8: optional bool needResult=true, - 9: optional string catName + 9: optional string catName, + 10: optional bool skipColumnSchemaForPartition +} + +struct DropPartitionRequest { + 1: optional string catName, + 2: required string dbName, + 3: required string tblName, + 4: optional string partName, + 5: optional list partVals, + 6: optional bool deleteData, + 7: optional EnvironmentContext environmentContext } struct PartitionValuesRequest { @@ -778,7 +985,8 @@ struct PartitionValuesRequest { 6: optional list partitionOrder; 7: optional bool ascending = true; 8: optional i64 maxParts = -1; - 9: optional string catName + 9: optional string catName, + 10: optional string validWriteIdList } struct PartitionValuesRow { @@ -789,6 +997,38 @@ struct PartitionValuesResponse { 1: required list partitionValues; } +struct GetPartitionsByNamesRequest { + 1: required string db_name, + 2: required string tbl_name, + 3: optional list names, + 4: optional bool get_col_stats, + 5: optional list processorCapabilities, + 6: optional string processorIdentifier, + 7: optional string engine = "hive", + 8: optional string validWriteIdList, + 9: optional bool getFileMetadata, + 10: optional i64 id=-1, // table id + 11: optional bool skipColumnSchemaForPartition, + 12: optional string includeParamKeyPattern, + 13: optional string excludeParamKeyPattern +} + +struct GetPartitionsByNamesResult { + 1: required list partitions + 2: optional ObjectDictionary dictionary +} + +struct DataConnector { + 1: string name, + 2: string type, + 3: string url, + 4: optional string description, + 5: optional map parameters, + 6: optional string ownerName, + 7: optional PrincipalType ownerType, + 8: optional i32 createTime +} + enum FunctionType { JAVA = 1, } @@ -799,6 +1039,23 @@ enum ResourceType { ARCHIVE = 3, } +enum TxnType { + DEFAULT = 0, + REPL_CREATED = 1, + READ_ONLY = 2, + COMPACTION = 3, + MATER_VIEW_REBUILD = 4, + SOFT_DELETE = 5, + REBALANCE_COMPACTION = 6 +} + +// specifies which info to return with GetTablesExtRequest +enum GetTablesExtRequestFields { + ACCESS_TYPE = 1, // return accessType + PROCESSOR_CAPABILITIES = 2, // return ALL Capabilities for each Tables + ALL = 2147483647 +} + struct ResourceUri { 1: ResourceType resourceType, 2: string uri, @@ -849,6 +1106,7 @@ struct OpenTxnRequest { 4: optional string agentInfo = "Unknown", 5: optional string replPolicy, 6: optional list replSrcTxnIds, + 7: optional TxnType txn_type = TxnType.DEFAULT, } struct OpenTxnsResponse { @@ -858,15 +1116,57 @@ struct OpenTxnsResponse { struct AbortTxnRequest { 1: required i64 txnid, 2: optional string replPolicy, + 3: optional TxnType txn_type, + 4: optional i64 errorCode, } struct AbortTxnsRequest { 1: required list txn_ids, + 2: optional i64 errorCode, +} + +struct CommitTxnKeyValue { + 1: required i64 tableId, + 2: required string key, + 3: required string value, +} + +struct WriteEventInfo { + 1: required i64 writeId, + 2: required string database, + 3: required string table, + 4: required string files, + 5: optional string partition, + 6: optional string tableObj, // repl txn task does not need table object for commit + 7: optional string partitionObj, +} + +struct ReplLastIdInfo { + 1: required string database, + 2: required i64 lastReplId, + 3: optional string table, + 4: optional string catalog, + 5: optional list partitionList, +} + +struct UpdateTransactionalStatsRequest { + 1: required i64 tableId, + 2: required i64 insertCount, + 3: required i64 updatedCount, + 4: required i64 deletedCount, } struct CommitTxnRequest { 1: required i64 txnid, 2: optional string replPolicy, + // Information related to write operations done in this transaction. + 3: optional list writeEventInfos, + // Information to update the last repl id of table/partition along with commit txn (replication from 2.6 to 3.0) + 4: optional ReplLastIdInfo replLastIdInfo, + // An optional key/value to store atomically with the transaction + 5: optional CommitTxnKeyValue keyValue, + 6: optional bool exclWriteEnabled = true, + 7: optional TxnType txn_type, } struct ReplTblWriteIdStateRequest { @@ -881,7 +1181,8 @@ struct ReplTblWriteIdStateRequest { // Request msg to get the valid write ids list for the given list of tables wrt to input validTxnList struct GetValidWriteIdsRequest { 1: required list fullTableNames, // Full table names of format . - 2: required string validTxnList, // Valid txn list string wrt the current txn of the caller + 2: optional string validTxnList, // Valid txn list string wrt the current txn of the caller + 3: optional i64 writeId, //write id to be used to get the current txn id } // Valid Write ID list of one table wrt to current txn @@ -898,6 +1199,12 @@ struct GetValidWriteIdsResponse { 1: required list tblValidWriteIds, } +// Map for allocated write id against the txn for which it is allocated +struct TxnToWriteId { + 1: required i64 txnId, + 2: required i64 writeId, +} + // Request msg to allocate table write ids for the given list of txns struct AllocateTableWriteIdsRequest { 1: required string dbName, @@ -908,18 +1215,31 @@ struct AllocateTableWriteIdsRequest { 4: optional string replPolicy, // The list is assumed to be sorted by both txnids and write ids. The write id list is assumed to be contiguous. 5: optional list srcTxnToWriteIdList, -} - -// Map for allocated write id against the txn for which it is allocated -struct TxnToWriteId { - 1: required i64 txnId, - 2: required i64 writeId, + // If false, reuse previously allocate writeIds for txnIds. If true, remove older txnId to writeIds mappings + // and regenerate (this is useful during re-compilation when we need to ensure writeIds are regenerated) + 6: optional bool reallocate = false; } struct AllocateTableWriteIdsResponse { 1: required list txnToWriteIds, } +struct MaxAllocatedTableWriteIdRequest { + 1: required string dbName, + 2: required string tableName, +} +struct MaxAllocatedTableWriteIdResponse { + 1: required i64 maxWriteId, +} +struct SeedTableWriteIdsRequest { + 1: required string dbName, + 2: required string tableName, + 3: required i64 seedWriteId, +} +struct SeedTxnIdRequest { + 1: required i64 seedTxnId, +} + struct LockComponent { 1: required LockType type, 2: required LockLevel level, @@ -937,11 +1257,15 @@ struct LockRequest { 3: required string user, // used in 'show locks' to help admins find who has open locks 4: required string hostname, // used in 'show locks' to help admins find who has open locks 5: optional string agentInfo = "Unknown", + 6: optional bool zeroWaitReadEnabled = false, + 7: optional bool exclusiveCTAS = false, + 8: optional bool locklessReadsEnabled = false } struct LockResponse { 1: required i64 lockid, 2: required LockState state, + 3: optional string errorMessage } struct CheckLockRequest { @@ -959,6 +1283,7 @@ struct ShowLocksRequest { 2: optional string tablename, 3: optional string partname, 4: optional bool isExtended=false, + 5: optional i64 txnid, } struct ShowLocksResponseElement { @@ -1000,21 +1325,89 @@ struct HeartbeatTxnRangeResponse { } struct CompactionRequest { - 1: required string dbname, - 2: required string tablename, - 3: optional string partitionname, - 4: required CompactionType type, - 5: optional string runas, + 1: required string dbname + 2: required string tablename + 3: optional string partitionname + 4: required CompactionType type + 5: optional string runas 6: optional map properties + 7: optional string initiatorId + 8: optional string initiatorVersion + 9: optional string poolName + 10: optional i32 numberOfBuckets + 11: optional string orderByClause; +} + +struct CompactionInfoStruct { + 1: required i64 id, + 2: required string dbname, + 3: required string tablename, + 4: optional string partitionname, + 5: required CompactionType type, + 6: optional string runas, + 7: optional string properties, + 8: optional bool toomanyaborts, + 9: optional string state, + 10: optional string workerId, + 11: optional i64 start, + 12: optional i64 highestWriteId, + 13: optional string errorMessage, + 14: optional bool hasoldabort, + 15: optional i64 enqueueTime, + 16: optional i64 retryRetention, + 17: optional string poolname + 18: optional i32 numberOfBuckets + 19: optional string orderByClause; +} + +struct OptionalCompactionInfoStruct { + 1: optional CompactionInfoStruct ci, +} + +enum CompactionMetricsMetricType { + NUM_OBSOLETE_DELTAS, + NUM_DELTAS, + NUM_SMALL_DELTAS, +} + +struct CompactionMetricsDataStruct { + 1: required string dbname + 2: required string tblname + 3: optional string partitionname + 4: required CompactionMetricsMetricType type + 5: required i32 metricvalue + 6: required i32 version + 7: required i32 threshold +} + +struct CompactionMetricsDataResponse { + 1: optional CompactionMetricsDataStruct data +} + +struct CompactionMetricsDataRequest { + 1: required string dbName, + 2: required string tblName, + 3: optional string partitionName + 4: required CompactionMetricsMetricType type } struct CompactionResponse { 1: required i64 id, 2: required string state, - 3: required bool accepted + 3: required bool accepted, + 4: optional string errormessage } struct ShowCompactRequest { + 1: optional i64 id, + 2: optional string poolName, + 3: optional string dbName, + 4: optional string tbName, + 5: optional string partName, + 6: optional CompactionType type, + 7: optional string state, + 8: optional i64 limit, + 9: optional string order } struct ShowCompactResponseElement { @@ -1031,12 +1424,57 @@ struct ShowCompactResponseElement { 11: optional i64 endTime, 12: optional string hadoopJobId = "None", 13: optional i64 id, + 14: optional string errorMessage, + 15: optional i64 enqueueTime, + 16: optional string workerVersion, + 17: optional string initiatorId, + 18: optional string initiatorVersion, + 19: optional i64 cleanerStart, + 20: optional string poolName, + 21: optional i64 nextTxnId, + 22: optional i64 txnId, + 23: optional i64 commitTime, + 24: optional i64 hightestWriteId + } struct ShowCompactResponse { 1: required list compacts, } +struct AbortCompactionRequest { + 1: required list compactionIds, + 2: optional string type, + 3: optional string poolName +} + +struct AbortCompactionResponseElement { + 1: required i64 compactionId, + 2: optional string status, + 3: optional string message +} + +struct AbortCompactResponse { + 1: required map abortedcompacts, +} + +struct GetLatestCommittedCompactionInfoRequest { + 1: required string dbname, + 2: required string tablename, + 3: optional list partitionnames, + 4: optional i64 lastCompactionId, +} + +struct GetLatestCommittedCompactionInfoResponse { + 1: required list compactions, +} + +struct FindNextCompactRequest { + 1: optional string workerId, + 2: optional string workerVersion, + 3: optional string poolName +} + struct AddDynamicPartitions { 1: required i64 txnid, 2: required i64 writeid, @@ -1055,18 +1493,14 @@ struct BasicTxnInfo { 6: optional string partitionname } -struct CreationMetadata { - 1: required string catName - 2: required string dbName, - 3: required string tblName, - 4: required set tablesUsed, - 5: optional string validTxnList, - 6: optional i64 materializationTime -} struct NotificationEventRequest { 1: required i64 lastEvent, 2: optional i32 maxEvents, + 3: optional list eventTypeSkipList, + 4: optional string catName, + 5: optional string dbName, + 6: optional list tableNames } struct NotificationEvent { @@ -1091,7 +1525,10 @@ struct CurrentNotificationEventId { struct NotificationEventsCountRequest { 1: required i64 fromEventId, 2: required string dbName, - 3: optional string catName + 3: optional string catName, + 4: optional i64 toEventId, + 5: optional i64 limit, + 6: optional list tableNames } struct NotificationEventsCountResponse { @@ -1103,10 +1540,18 @@ struct InsertEventRequestData { 2: required list filesAdded, // Checksum of files (hex string of checksum byte payload) 3: optional list filesAddedChecksum, + // Used by acid operation to create the sub directory + 4: optional list subDirectoryList, + // partition value which was inserted (used in case of bulk insert events) + 5: optional list partitionVal } union FireEventRequestData { - 1: InsertEventRequestData insertData + 1: optional InsertEventRequestData insertData, + // used to fire insert events on multiple partitions + 2: optional list insertDatas, + // Identify if it is a refresh or invalidate event + 3: optional bool refreshEvent } struct FireEventRequest { @@ -1116,11 +1561,37 @@ struct FireEventRequest { // subevent as I assume they'll be used across most event types. 3: optional string dbName, 4: optional string tableName, + // ignored if event request data contains multiple insert event datas 5: optional list partitionVals, 6: optional string catName, + 7: optional map tblParams, } struct FireEventResponse { + 1: list eventIds +} + +struct WriteNotificationLogRequest { + 1: required i64 txnId, + 2: required i64 writeId, + 3: required string db, + 4: required string table, + 5: required InsertEventRequestData fileInfo, + 6: optional list partitionVals, +} + +struct WriteNotificationLogResponse { + // NOP for now, this is just a place holder for future responses +} + +struct WriteNotificationLogBatchRequest { + 1: required string catalog, + 2: required string db, + 3: required string table, + 4: required list requestList, +} + +struct WriteNotificationLogBatchResponse { // NOP for now, this is just a place holder for future responses } @@ -1201,33 +1672,129 @@ enum ClientCapability { INSERT_ONLY_TABLES = 2 } - struct ClientCapabilities { 1: required list values } +/* + * Generic request API, providing different kinds of filtering and controlling output. + * + * The API entry point is get_partitions_with_specs() and getTables, which is based on a single + * request/response object model. + * + * The request defines any filtering that should be done for partitions as well as the list of fields that should be + * returned (this is called ProjectionSpec). Projection is simply a list of dot separated strings which represent + * the fields which that be returned. Projection may also include whitelist or blacklist of parameters to include in + * the partition. When both blacklist and whitelist are present, the blacklist supersedes the + * whitelist in case of conflicts. + * + * Filter spec is the generalization of various types of partition and table filtering. Partitions and tables can be + * filtered by names, by values or by partition expressions. + */ + +struct GetProjectionsSpec { + // fieldList is a list of dot separated strings which represent the fields which must be returned. + // Any other field which is not in the fieldList may be unset in the returned partitions (it + // is up to the implementation to decide whether it chooses to include or exclude such fields). + // E.g. setting the field list to sd.location, serdeInfo.name, sd.cols.name, sd.cols.type will + // return partitions which will have location field set in the storage descriptor. Also the serdeInfo + // in the returned storage descriptor will only have name field set. This applies to multi-valued + // fields as well like sd.cols, so in the example above only name and type fields will be set for sd.cols. + // If the fieldList is empty or not present, all the fields will be set + 1: list fieldList; + // SQL-92 compliant regex pattern for param keys to be included + // _ or % wildcards are supported. '_' represent one character and '%' represents 0 or more characters + // Currently this is unsupported when fetching tables. + 2: string includeParamKeyPattern; + // SQL-92 compliant regex pattern for param keys to be excluded + // _ or % wildcards are supported. '_' represent one character and '%' represents 0 or more characters + // Current this is unsupported when fetching tables. + 3: string excludeParamKeyPattern; +} + struct GetTableRequest { 1: required string dbName, 2: required string tblName, 3: optional ClientCapabilities capabilities, - 4: optional string catName + 4: optional string catName, + 6: optional string validWriteIdList, + 7: optional bool getColumnStats, + 8: optional list processorCapabilities, + 9: optional string processorIdentifier, + 10: optional string engine = "hive", + 11: optional i64 id=-1 // table id } struct GetTableResult { - 1: required Table table + 1: required Table table, + 2: optional bool isStatsCompliant } struct GetTablesRequest { 1: required string dbName, 2: optional list tblNames, 3: optional ClientCapabilities capabilities, - 4: optional string catName + 4: optional string catName, + 5: optional list processorCapabilities, + 6: optional string processorIdentifier, + 7: optional GetProjectionsSpec projectionSpec, + 8: optional string tablesPattern } struct GetTablesResult { 1: required list
tables } +struct GetTablesExtRequest { + 1: required string catalog, + 2: required string database, + 3: required string tableNamePattern, // table name matching pattern + 4: required i32 requestedFields, // ORed GetTablesExtRequestFields + 5: optional i32 limit, // maximum number of tables returned (0=all) + 6: optional list processorCapabilities, // list of capabilities “possessed” by the client + 7: optional string processorIdentifier +} + +// response to GetTablesExtRequest call +struct ExtendedTableInfo { + 1: required string tblName, // always returned + 2: optional i32 accessType, // if AccessType set + 3: optional list requiredReadCapabilities // capabilities required for read access + 4: optional list requiredWriteCapabilities // capabilities required for write access +} + +struct DropTableRequest { + 1: optional string catalogName, + 2: required string dbName, + 3: required string tableName, + 4: optional bool deleteData, + 5: optional EnvironmentContext envContext, + 6: optional bool dropPartitions +} + +struct GetDatabaseRequest { + 1: optional string name, + 2: optional string catalogName, + 3: optional list processorCapabilities, + 4: optional string processorIdentifier +} + +struct AlterDatabaseRequest { + 1: required string oldDbName, + 2: required Database newDb +} + +struct DropDatabaseRequest { + 1: required string name, + 2: optional string catalogName, + 3: required bool ignoreUnknownDb, + 4: required bool deleteData, + 5: required bool cascade, + 6: optional bool softDelete=false, + 7: optional i64 txnId=0, + 8: optional bool deleteManagedDir=true +} + // Request type for cm_recycle struct CmRecycleRequest { 1: required string dataPath, @@ -1244,10 +1811,13 @@ struct TableMeta { 3: required string tableType; 4: optional string comments; 5: optional string catName; + 6: optional string ownerName; + 7: optional PrincipalType ownerType; } struct Materialization { 1: required bool sourceTablesUpdateDeleteModified; + 2: required bool sourceTablesCompacted; } // Data types for workload management. @@ -1268,6 +1838,7 @@ struct WMResourcePlan { 2: optional WMResourcePlanStatus status; 3: optional i32 queryParallelism; 4: optional string defaultPoolPath; + 5: optional string ns; } struct WMNullableResourcePlan { @@ -1277,6 +1848,7 @@ struct WMNullableResourcePlan { 5: optional bool isSetQueryParallelism; 6: optional string defaultPoolPath; 7: optional bool isSetDefaultPoolPath; + 8: optional string ns; } struct WMPool { @@ -1285,6 +1857,7 @@ struct WMPool { 3: optional double allocFraction; 4: optional i32 queryParallelism; 5: optional string schedulingPolicy; + 6: optional string ns; } @@ -1295,6 +1868,7 @@ struct WMNullablePool { 4: optional i32 queryParallelism; 5: optional string schedulingPolicy; 6: optional bool isSetSchedulingPolicy; + 7: optional string ns; } struct WMTrigger { @@ -1303,6 +1877,7 @@ struct WMTrigger { 3: optional string triggerExpression; 4: optional string actionExpression; 5: optional bool isInUnmanaged; + 6: optional string ns; } struct WMMapping { @@ -1311,11 +1886,13 @@ struct WMMapping { 3: required string entityName; 4: optional string poolPath; 5: optional i32 ordering; + 6: optional string ns; } struct WMPoolTrigger { 1: required string pool; 2: required string trigger; + 3: optional string ns; } struct WMFullResourcePlan { @@ -1337,6 +1914,7 @@ struct WMCreateResourcePlanResponse { } struct WMGetActiveResourcePlanRequest { + 1: optional string ns; } struct WMGetActiveResourcePlanResponse { @@ -1345,6 +1923,7 @@ struct WMGetActiveResourcePlanResponse { struct WMGetResourcePlanRequest { 1: optional string resourcePlanName; + 2: optional string ns; } struct WMGetResourcePlanResponse { @@ -1352,6 +1931,7 @@ struct WMGetResourcePlanResponse { } struct WMGetAllResourcePlanRequest { + 1: optional string ns; } struct WMGetAllResourcePlanResponse { @@ -1364,6 +1944,7 @@ struct WMAlterResourcePlanRequest { 3: optional bool isEnableAndActivate; 4: optional bool isForceDeactivate; 5: optional bool isReplace; + 6: optional string ns; } struct WMAlterResourcePlanResponse { @@ -1372,6 +1953,7 @@ struct WMAlterResourcePlanResponse { struct WMValidateResourcePlanRequest { 1: optional string resourcePlanName; + 2: optional string ns; } struct WMValidateResourcePlanResponse { @@ -1381,6 +1963,7 @@ struct WMValidateResourcePlanResponse { struct WMDropResourcePlanRequest { 1: optional string resourcePlanName; + 2: optional string ns; } struct WMDropResourcePlanResponse { @@ -1403,6 +1986,7 @@ struct WMAlterTriggerResponse { struct WMDropTriggerRequest { 1: optional string resourcePlanName; 2: optional string triggerName; + 3: optional string ns; } struct WMDropTriggerResponse { @@ -1410,6 +1994,7 @@ struct WMDropTriggerResponse { struct WMGetTriggersForResourePlanRequest { 1: optional string resourcePlanName; + 2: optional string ns; } struct WMGetTriggersForResourePlanResponse { @@ -1434,6 +2019,7 @@ struct WMAlterPoolResponse { struct WMDropPoolRequest { 1: optional string resourcePlanName; 2: optional string poolPath; + 3: optional string ns; } struct WMDropPoolResponse { @@ -1459,6 +2045,7 @@ struct WMCreateOrDropTriggerToPoolMappingRequest { 2: optional string triggerName; 3: optional string poolPath; 4: optional bool drop; + 5: optional string ns; } struct WMCreateOrDropTriggerToPoolMappingResponse { @@ -1542,6 +2129,374 @@ struct GetRuntimeStatsRequest { 2: required i32 maxCreateTime } +struct CreateTableRequest { + 1: required Table table, + 2: optional EnvironmentContext envContext, + 3: optional list primaryKeys, + 4: optional list foreignKeys, + 5: optional list uniqueConstraints, + 6: optional list notNullConstraints, + 7: optional list defaultConstraints, + 8: optional list checkConstraints, + 9: optional list processorCapabilities, + 10: optional string processorIdentifier +} + +struct CreateDatabaseRequest { + 1: required string databaseName, + 2: optional string description, + 3: optional string locationUri, + 4: optional map parameters, + 5: optional PrincipalPrivilegeSet privileges, + 6: optional string ownerName, + 7: optional PrincipalType ownerType, + 8: optional string catalogName, + 9: optional i32 createTime, + 10: optional string managedLocationUri, + 11: optional DatabaseType type, + 12: optional string dataConnectorName, + 13: optional string remote_dbname +} + +struct CreateDataConnectorRequest { + 1: required DataConnector connector +} + +struct GetDataConnectorRequest { + 1: required string connectorName +} + +struct AlterDataConnectorRequest { + 1: required string connectorName, + 2: required DataConnector newConnector +} + +struct DropDataConnectorRequest { + 1: required string connectorName, + 2: optional bool ifNotExists, + 3: optional bool checkReferences +} + +struct ScheduledQueryPollRequest { + 1: required string clusterNamespace +} + +struct ScheduledQueryKey { + 1: required string scheduleName, + 2: required string clusterNamespace, +} + +struct ScheduledQueryPollResponse { + 1: optional ScheduledQueryKey scheduleKey, + 2: optional i64 executionId, + 3: optional string query, + 4: optional string user, +} + +struct ScheduledQuery { + 1: required ScheduledQueryKey scheduleKey, + 2: optional bool enabled, + 4: optional string schedule, + 5: optional string user, + 6: optional string query, + 7: optional i32 nextExecution, +} + +enum ScheduledQueryMaintenanceRequestType { + CREATE = 1, + ALTER = 2, + DROP = 3, +} + +struct ScheduledQueryMaintenanceRequest { + 1: required ScheduledQueryMaintenanceRequestType type, + 2: required ScheduledQuery scheduledQuery, +} + +enum QueryState { + INITED, + EXECUTING, + FAILED, + FINISHED, + TIMED_OUT, + AUTO_DISABLED, +} + +struct ScheduledQueryProgressInfo{ + 1: required i64 scheduledExecutionId, + 2: required QueryState state, + 3: required string executorQueryId, + 4: optional string errorMessage, +} + +struct AlterPartitionsRequest { + 1: optional string catName, + 2: required string dbName, + 3: required string tableName, + 4: required list partitions, + 5: optional EnvironmentContext environmentContext, + 6: optional i64 writeId=-1, + 7: optional string validWriteIdList, + 8: optional bool skipColumnSchemaForPartition, + 9: optional list partitionColSchema +} + +struct AppendPartitionsRequest { + 1: optional string catalogName, + 2: required string dbName, + 3: required string tableName, + 4: optional string name, + 5: optional list partVals, + 6: optional EnvironmentContext environmentContext +} + +struct AlterPartitionsResponse { +} + +struct RenamePartitionRequest { + 1: optional string catName, + 2: required string dbName, + 3: required string tableName, + 4: required list partVals, + 5: required Partition newPart, + 6: optional string validWriteIdList, + 7: optional i64 txnId, // txnId associated with the rename operation + 8: optional bool clonePart // non-blocking rename +} + +struct RenamePartitionResponse { +} + +struct AlterTableRequest { + 1: optional string catName, + 2: required string dbName, + 3: required string tableName, + 4: required Table table, + 5: optional EnvironmentContext environmentContext, + 6: optional i64 writeId=-1, + 7: optional string validWriteIdList + 8: optional list processorCapabilities, + 9: optional string processorIdentifier, + 10: optional string expectedParameterKey, + 11: optional string expectedParameterValue +// TODO: also add cascade here, out of envCtx +} + +struct AlterTableResponse { +} + +enum PartitionFilterMode { + BY_NAMES, // filter by names + BY_VALUES, // filter by values + BY_EXPR // filter by expression +} + +struct GetPartitionsFilterSpec { + 7: optional PartitionFilterMode filterMode, + 8: optional list filters //used as list of partitionNames or list of values or expressions depending on mode +} + +struct GetPartitionsResponse { + 1: list partitionSpec +} + +struct GetPartitionsRequest { + 1: optional string catName, + 2: string dbName, + 3: string tblName, + 4: optional bool withAuth, + 5: optional string user, + 6: optional list groupNames, + 7: GetProjectionsSpec projectionSpec + 8: GetPartitionsFilterSpec filterSpec, + 9: optional list processorCapabilities, + 10: optional string processorIdentifier, + 11: optional string validWriteIdList +} + +struct GetFieldsRequest { + 1: optional string catName, + 2: required string dbName, + 3: required string tblName, + 4: optional EnvironmentContext envContext, + 5: optional string validWriteIdList, + 6: optional i64 id=-1 // table id +} + +struct GetFieldsResponse { + 1: required list fields +} + +struct GetSchemaRequest { + 1: optional string catName, + 2: required string dbName, + 3: required string tblName, + 4: optional EnvironmentContext envContext, + 5: optional string validWriteIdList, + 6: optional i64 id=-1 // table id +} + +struct GetSchemaResponse { + 1: required list fields +} + +struct GetPartitionRequest { + 1: optional string catName, + 2: required string dbName, + 3: required string tblName, + 4: required list partVals, + 5: optional string validWriteIdList, + 6: optional i64 id=-1 // table id +} + +struct GetPartitionResponse { + 1: required Partition partition +} + +struct PartitionsRequest { // Not using Get prefix as that name is already used for a different method + 1: optional string catName, + 2: required string dbName, + 3: required string tblName, + 4: optional i16 maxParts=-1, + 5: optional string validWriteIdList, + 6: optional i64 id=-1, // table id + 7: optional bool skipColumnSchemaForPartition, + 8: optional string includeParamKeyPattern, + 9: optional string excludeParamKeyPattern +} + +struct PartitionsResponse { // Not using Get prefix as that name is already used for a different method + 1: required list partitions +} + +struct GetPartitionsByFilterRequest { + 1: optional string catName, + 2: string dbName, + 3: string tblName, + 4: string filter, + 5: optional i16 maxParts=-1, + 6: optional bool skipColumnSchemaForPartition, + 7: optional string includeParamKeyPattern, + 8: optional string excludeParamKeyPattern +} + +struct GetPartitionNamesPsRequest { + 1: optional string catName, + 2: required string dbName, + 3: required string tblName, + 4: optional list partValues, + 5: optional i16 maxParts=-1, + 6: optional string validWriteIdList, + 7: optional i64 id=-1 // table id +} + +struct GetPartitionNamesPsResponse { + 1: required list names +} + +struct GetPartitionsPsWithAuthRequest { + 1: optional string catName, + 2: required string dbName, + 3: required string tblName, + 4: optional list partVals, + 5: optional i16 maxParts=-1, + 6: optional string userName, + 7: optional list groupNames, + 8: optional string validWriteIdList, + 9: optional i64 id=-1 // table id + 10: optional bool skipColumnSchemaForPartition, + 11: optional string includeParamKeyPattern, + 12: optional string excludeParamKeyPattern, + 13: optional list partNames; +} + +struct GetPartitionsPsWithAuthResponse { + 1: required list partitions +} + +struct ReplicationMetrics{ + 1: required i64 scheduledExecutionId, + 2: required string policy, + 3: required i64 dumpExecutionId, + 4: optional string metadata, + 5: optional string progress, + 6: optional string messageFormat +} + +struct ReplicationMetricList{ + 1: required list replicationMetricList, +} + +struct GetReplicationMetricsRequest { + 1: optional i64 scheduledExecutionId, + 2: optional string policy, + 3: optional i64 dumpExecutionId +} + +struct GetOpenTxnsRequest { + 1: optional list excludeTxnTypes; +} + +struct StoredProcedureRequest { + 1: required string catName, + 2: required string dbName, + 3: required string procName +} + +struct ListStoredProcedureRequest { + 1: required string catName + 2: optional string dbName +} + +struct StoredProcedure { + 1: string name, + 2: string dbName, + 3: string catName, + 4: string ownerName, + 5: string source +} + +struct AddPackageRequest { + 1: string catName, + 2: string dbName, + 3: string packageName + 4: string ownerName, + 5: string header, + 6: string body +} + +struct GetPackageRequest { + 1: required string catName, + 2: required string dbName, + 3: required string packageName +} + +struct DropPackageRequest { + 1: required string catName, + 2: required string dbName, + 3: required string packageName +} + +struct ListPackageRequest { + 1: required string catName + 2: optional string dbName +} + +struct Package { + 1: string catName, + 2: string dbName, + 3: string packageName + 4: string ownerName, + 5: string header, + 6: string body +} + +struct GetAllWriteEventInfoRequest { + 1: required i64 txnId, + 2: optional string dbName, + 3: optional string tableName +} + // Exceptions. exception MetaException { @@ -1605,11 +2560,19 @@ exception NoSuchLockException { 1: string message } +exception CompactionAbortedException { + 1: string message +} + +exception NoSuchCompactionException { + 1: string message +} /** * This interface is live. */ service ThriftHiveMetastore extends fb303.FacebookService { + AbortCompactResponse abort_Compactions(1: AbortCompactionRequest rqst) string getMetaConf(1:string key) throws(1:MetaException o1) void setMetaConf(1:string key, 2:string value) throws(1:MetaException o1) @@ -1620,13 +2583,23 @@ service ThriftHiveMetastore extends fb303.FacebookService void drop_catalog(1: DropCatalogRequest catName) throws (1:NoSuchObjectException o1, 2:InvalidOperationException o2, 3:MetaException o3) void create_database(1:Database database) throws(1:AlreadyExistsException o1, 2:InvalidObjectException o2, 3:MetaException o3) + void create_database_req(1:CreateDatabaseRequest createDatabaseRequest) throws(1:AlreadyExistsException o1, 2:InvalidObjectException o2, 3:MetaException o3) Database get_database(1:string name) throws(1:NoSuchObjectException o1, 2:MetaException o2) + Database get_database_req(1:GetDatabaseRequest request) throws(1:NoSuchObjectException o1, 2:MetaException o2) void drop_database(1:string name, 2:bool deleteData, 3:bool cascade) throws(1:NoSuchObjectException o1, 2:InvalidOperationException o2, 3:MetaException o3) + void drop_database_req(1:DropDatabaseRequest req) throws(1:NoSuchObjectException o1, 2:InvalidOperationException o2, 3:MetaException o3) list get_databases(1:string pattern) throws(1:MetaException o1) list get_all_databases() throws(1:MetaException o1) void alter_database(1:string dbname, 2:Database db) throws(1:MetaException o1, 2:NoSuchObjectException o2) + void alter_database_req(1:AlterDatabaseRequest alterDbReq) throws(1:MetaException o1, 2:NoSuchObjectException o2) + + void create_dataconnector_req(1:CreateDataConnectorRequest connectorReq) throws(1:AlreadyExistsException o1, 2:InvalidObjectException o2, 3:MetaException o3) + DataConnector get_dataconnector_req(1:GetDataConnectorRequest request) throws(1:NoSuchObjectException o1, 2:MetaException o2) + void drop_dataconnector_req(1:DropDataConnectorRequest dropDcReq) throws(1:NoSuchObjectException o1, 2:InvalidOperationException o2, 3:MetaException o3) + list get_dataconnectors() throws(1:MetaException o1) + void alter_dataconnector_req(1:AlterDataConnectorRequest alterReq) throws(1:MetaException o1, 2:NoSuchObjectException o2) - // returns the type with given name (make seperate calls for the dependent types if needed) + // returns the type with given name (make seperate calls for the dependent types if needed) Type get_type(1:string name) throws(1:MetaException o1, 2:NoSuchObjectException o2) bool create_type(1:Type type) throws(1:AlreadyExistsException o1, 2:InvalidObjectException o2, 3:MetaException o3) bool drop_type(1:string type) throws(1:MetaException o1, 2:NoSuchObjectException o2) @@ -1634,12 +2607,18 @@ service ThriftHiveMetastore extends fb303.FacebookService throws(1:MetaException o2) // Gets a list of FieldSchemas describing the columns of a particular table - list get_fields(1: string db_name, 2: string table_name) throws (1: MetaException o1, 2: UnknownTableException o2, 3: UnknownDBException o3), - list get_fields_with_environment_context(1: string db_name, 2: string table_name, 3:EnvironmentContext environment_context) throws (1: MetaException o1, 2: UnknownTableException o2, 3: UnknownDBException o3) + list get_fields(1:string db_name, 2:string table_name) throws(1:MetaException o1, 2:UnknownTableException o2, 3:UnknownDBException o3) + list get_fields_with_environment_context(1:string db_name, 2:string table_name, 3:EnvironmentContext environment_context) throws(1:MetaException o1, 2:UnknownTableException o2, 3:UnknownDBException o3) + + GetFieldsResponse get_fields_req(1: GetFieldsRequest req) + throws(1:MetaException o1, 2:UnknownTableException o2, 3:UnknownDBException o3) // Gets a list of FieldSchemas describing both the columns and the partition keys of a particular table - list get_schema(1: string db_name, 2: string table_name) throws (1: MetaException o1, 2: UnknownTableException o2, 3: UnknownDBException o3) - list get_schema_with_environment_context(1: string db_name, 2: string table_name, 3:EnvironmentContext environment_context) throws (1: MetaException o1, 2: UnknownTableException o2, 3: UnknownDBException o3) + list get_schema(1:string db_name, 2:string table_name) throws(1:MetaException o1, 2: UnknownTableException o2, 3: UnknownDBException o3) + list get_schema_with_environment_context(1:string db_name, 2:string table_name, 3:EnvironmentContext environment_context) throws(1:MetaException o1, 2:UnknownTableException o2, 3:UnknownDBException o3) + + GetSchemaResponse get_schema_req(1: GetSchemaRequest req) + throws(1:MetaException o1, 2:UnknownTableException o2, 3:UnknownDBException o3) // create a Hive table. Following fields must be set // tableName @@ -1657,11 +2636,14 @@ service ThriftHiveMetastore extends fb303.FacebookService 2:InvalidObjectException o2, 3:MetaException o3, 4:NoSuchObjectException o4) void create_table_with_constraints(1:Table tbl, 2: list primaryKeys, 3: list foreignKeys, - 4: list uniqueConstraints, 5: list notNullConstraints, - 6: list defaultConstraints, 7: list checkConstraints) + 4: list uniqueConstraints, 5: list notNullConstraints, + 6: list defaultConstraints, 7: list checkConstraints) throws (1:AlreadyExistsException o1, 2:InvalidObjectException o2, 3:MetaException o3, 4:NoSuchObjectException o4) + void create_table_req(1:CreateTableRequest request) throws (1:AlreadyExistsException o1, + 2:InvalidObjectException o2, 3:MetaException o3, + 4:NoSuchObjectException o4) void drop_constraint(1:DropConstraintRequest req) throws(1:NoSuchObjectException o1, 2:MetaException o3) void add_primary_key(1:AddPrimaryKeyRequest req) @@ -1676,7 +2658,8 @@ service ThriftHiveMetastore extends fb303.FacebookService throws(1:NoSuchObjectException o1, 2:MetaException o2) void add_check_constraint(1:AddCheckConstraintRequest req) throws(1:NoSuchObjectException o1, 2:MetaException o2) - + Table translate_table_dryrun(1:CreateTableRequest request) + throws(1:AlreadyExistsException o1, 2:InvalidObjectException o2, 3:MetaException o3, 4:NoSuchObjectException o4) // drops the table and all the partitions associated with it if the table has partitions // delete data (including partitions) if deleteData is set to true void drop_table(1:string dbname, 2:string name, 3:bool deleteData) @@ -1684,18 +2667,20 @@ service ThriftHiveMetastore extends fb303.FacebookService void drop_table_with_environment_context(1:string dbname, 2:string name, 3:bool deleteData, 4:EnvironmentContext environment_context) throws(1:NoSuchObjectException o1, 2:MetaException o3) + void drop_table_req(1:DropTableRequest dropTableReq) + throws(1:NoSuchObjectException o1, 2:MetaException o3) void truncate_table(1:string dbName, 2:string tableName, 3:list partNames) throws(1:MetaException o1) + TruncateTableResponse truncate_table_req(1:TruncateTableRequest req) throws(1:MetaException o1) list get_tables(1: string db_name, 2: string pattern) throws (1: MetaException o1) list get_tables_by_type(1: string db_name, 2: string pattern, 3: string tableType) throws (1: MetaException o1) + list
get_all_materialized_view_objects_for_rewriting() throws (1:MetaException o1) list get_materialized_views_for_rewriting(1: string db_name) throws (1: MetaException o1) list get_table_meta(1: string db_patterns, 2: string tbl_patterns, 3: list tbl_types) throws (1: MetaException o1) list get_all_tables(1: string db_name) throws (1: MetaException o1) - Table get_table(1:string dbname, 2:string tbl_name) - throws (1:MetaException o1, 2:NoSuchObjectException o2) - list
get_table_objects_by_name(1:string dbname, 2:list tbl_names) + list get_tables_ext(1: GetTablesExtRequest req) throws (1: MetaException o1) GetTableResult get_table_req(1:GetTableRequest req) throws (1:MetaException o1, 2:NoSuchObjectException o2) GetTablesResult get_table_objects_by_name_req(1:GetTablesRequest req) throws (1:MetaException o1, 2:InvalidOperationException o2, 3:UnknownDBException o3) @@ -1751,6 +2736,11 @@ service ThriftHiveMetastore extends fb303.FacebookService // alter table not only applies to future partitions but also cascade to existing partitions void alter_table_with_cascade(1:string dbname, 2:string tbl_name, 3:Table new_tbl, 4:bool cascade) throws (1:InvalidOperationException o1, 2:MetaException o2) + AlterTableResponse alter_table_req(1:AlterTableRequest req) + throws (1:InvalidOperationException o1, 2:MetaException o2) + + + // the following applies to only tables that have partitions // * See notes on DDL_TIME Partition add_partition(1:Partition new_part) @@ -1770,6 +2760,8 @@ service ThriftHiveMetastore extends fb303.FacebookService Partition append_partition_with_environment_context(1:string db_name, 2:string tbl_name, 3:list part_vals, 4:EnvironmentContext environment_context) throws (1:InvalidObjectException o1, 2:AlreadyExistsException o2, 3:MetaException o3) + Partition append_partition_req(1:AppendPartitionsRequest appendPartitionsReq) + throws (1:InvalidObjectException o1, 2:AlreadyExistsException o2, 3:MetaException o3) Partition append_partition_by_name(1:string db_name, 2:string tbl_name, 3:string part_name) throws (1:InvalidObjectException o1, 2:AlreadyExistsException o2, 3:MetaException o3) Partition append_partition_by_name_with_environment_context(1:string db_name, 2:string tbl_name, @@ -1780,6 +2772,8 @@ service ThriftHiveMetastore extends fb303.FacebookService bool drop_partition_with_environment_context(1:string db_name, 2:string tbl_name, 3:list part_vals, 4:bool deleteData, 5:EnvironmentContext environment_context) throws(1:NoSuchObjectException o1, 2:MetaException o2) + bool drop_partition_req(1:DropPartitionRequest dropPartitionReq) + throws(1:NoSuchObjectException o1, 2:MetaException o2) bool drop_partition_by_name(1:string db_name, 2:string tbl_name, 3:string part_name, 4:bool deleteData) throws(1:NoSuchObjectException o1, 2:MetaException o2) bool drop_partition_by_name_with_environment_context(1:string db_name, 2:string tbl_name, @@ -1790,6 +2784,8 @@ service ThriftHiveMetastore extends fb303.FacebookService Partition get_partition(1:string db_name, 2:string tbl_name, 3:list part_vals) throws(1:MetaException o1, 2:NoSuchObjectException o2) + GetPartitionResponse get_partition_req(1: GetPartitionRequest req) + throws(1:MetaException o1, 2:NoSuchObjectException o2) Partition exchange_partition(1:map partitionSpecs, 2:string source_db, 3:string source_table_name, 4:string dest_db, 5:string dest_table_name) throws(1:MetaException o1, 2:NoSuchObjectException o2, 3:InvalidObjectException o3, @@ -1810,6 +2806,8 @@ service ThriftHiveMetastore extends fb303.FacebookService // If max parts is given then it will return only that many. list get_partitions(1:string db_name, 2:string tbl_name, 3:i16 max_parts=-1) throws(1:NoSuchObjectException o1, 2:MetaException o2) +PartitionsResponse get_partitions_req(1:PartitionsRequest req) + throws(1:NoSuchObjectException o1, 2:MetaException o2) list get_partitions_with_auth(1:string db_name, 2:string tbl_name, 3:i16 max_parts=-1, 4: string user_name, 5: list group_names) throws(1:NoSuchObjectException o1, 2:MetaException o2) @@ -1818,7 +2816,8 @@ service ThriftHiveMetastore extends fb303.FacebookService list get_partition_names(1:string db_name, 2:string tbl_name, 3:i16 max_parts=-1) throws(1:NoSuchObjectException o1, 2:MetaException o2) - + list fetch_partition_names_req(1:PartitionsRequest partitionReq) + throws(1:NoSuchObjectException o1, 2:MetaException o2) PartitionValuesResponse get_partition_values(1:PartitionValuesRequest request) throws(1:MetaException o1, 2:NoSuchObjectException o2); @@ -1831,18 +2830,29 @@ service ThriftHiveMetastore extends fb303.FacebookService list get_partitions_ps(1:string db_name 2:string tbl_name 3:list part_vals, 4:i16 max_parts=-1) throws(1:MetaException o1, 2:NoSuchObjectException o2) - list get_partitions_ps_with_auth(1:string db_name, 2:string tbl_name, 3:list part_vals, 4:i16 max_parts=-1, + list get_partitions_ps_with_auth(1:string db_name, + 2:string tbl_name, 3:list part_vals, 4:i16 max_parts=-1, 5: string user_name, 6: list group_names) throws(1:NoSuchObjectException o1, 2:MetaException o2) + GetPartitionsPsWithAuthResponse get_partitions_ps_with_auth_req(1:GetPartitionsPsWithAuthRequest req) + throws(1:MetaException o1, 2:NoSuchObjectException o2) list get_partition_names_ps(1:string db_name, 2:string tbl_name, 3:list part_vals, 4:i16 max_parts=-1) throws(1:MetaException o1, 2:NoSuchObjectException o2) + GetPartitionNamesPsResponse get_partition_names_ps_req(1:GetPartitionNamesPsRequest req) + throws(1:MetaException o1, 2:NoSuchObjectException o2) + + list get_partition_names_req(1:PartitionsByExprRequest req) + throws(1:MetaException o1, 2:NoSuchObjectException o2) // get the partitions matching the given partition filter list get_partitions_by_filter(1:string db_name 2:string tbl_name 3:string filter, 4:i16 max_parts=-1) throws(1:MetaException o1, 2:NoSuchObjectException o2) + list get_partitions_by_filter_req(1:GetPartitionsByFilterRequest req) + throws(1:MetaException o1, 2:NoSuchObjectException o2) + // List partitions as PartitionSpec instances. list get_part_specs_by_filter(1:string db_name 2:string tbl_name 3:string filter, 4:i32 max_parts=-1) @@ -1855,12 +2865,25 @@ service ThriftHiveMetastore extends fb303.FacebookService throws(1:MetaException o1, 2:NoSuchObjectException o2) // get the partitions matching the given partition filter + // unlike get_partitions_by_expr, this returns PartitionSpec which contains deduplicated + // storage descriptor + PartitionsSpecByExprResult get_partitions_spec_by_expr(1:PartitionsByExprRequest req) + throws(1:MetaException o1, 2:NoSuchObjectException o2) + + // get the partitions matching the given partition filter i32 get_num_partitions_by_filter(1:string db_name 2:string tbl_name 3:string filter) throws(1:MetaException o1, 2:NoSuchObjectException o2) // get partitions give a list of partition names list get_partitions_by_names(1:string db_name 2:string tbl_name 3:list names) - throws(1:MetaException o1, 2:NoSuchObjectException o2) + throws(1:MetaException o1, 2:NoSuchObjectException o2, 3:InvalidObjectException o3) + GetPartitionsByNamesResult get_partitions_by_names_req(1:GetPartitionsByNamesRequest req) + throws(1:MetaException o1, 2:NoSuchObjectException o2, 3:InvalidObjectException o3) + + // retrieve properties + PropertyGetResponse get_properties(1:PropertyGetRequest req) throws(1:MetaException e1, 2:NoSuchObjectException e2); + // set properties + bool set_properties(1:PropertySetRequest req) throws(1:MetaException e1, 2:NoSuchObjectException e2); // changes the partition to the new partition object. partition is identified from the part values // in the new_part @@ -1872,8 +2895,12 @@ service ThriftHiveMetastore extends fb303.FacebookService // prehooks are fired together followed by all post hooks void alter_partitions(1:string db_name, 2:string tbl_name, 3:list new_parts) throws (1:InvalidOperationException o1, 2:MetaException o2) + void alter_partitions_with_environment_context(1:string db_name, 2:string tbl_name, 3:list new_parts, 4:EnvironmentContext environment_context) throws (1:InvalidOperationException o1, 2:MetaException o2) + AlterPartitionsResponse alter_partitions_req(1:AlterPartitionsRequest req) + throws (1:InvalidOperationException o1, 2:MetaException o2) + void alter_partition_with_environment_context(1:string db_name, 2:string tbl_name, 3:Partition new_part, 4:EnvironmentContext environment_context) @@ -1885,6 +2912,9 @@ service ThriftHiveMetastore extends fb303.FacebookService void rename_partition(1:string db_name, 2:string tbl_name, 3:list part_vals, 4:Partition new_part) throws (1:InvalidOperationException o1, 2:MetaException o2) + RenamePartitionResponse rename_partition_req(1:RenamePartitionRequest req) + throws (1:InvalidOperationException o1, 2:MetaException o2) + // returns whether or not the partition name is valid based on the value of the config // hive.metastore.partition.name.whitelist.pattern bool partition_name_has_valid_characters(1:list part_vals, 2:bool throw_exception) @@ -1928,6 +2958,9 @@ service ThriftHiveMetastore extends fb303.FacebookService throws(1:MetaException o1, 2:NoSuchObjectException o2) CheckConstraintsResponse get_check_constraints(1:CheckConstraintsRequest request) throws(1:MetaException o1, 2:NoSuchObjectException o2) + // All table constrains + AllTableConstraintsResponse get_all_table_constraints(1:AllTableConstraintsRequest request) + throws(1:MetaException o1, 2:NoSuchObjectException o2) // column statistics interfaces @@ -1940,6 +2973,14 @@ service ThriftHiveMetastore extends fb303.FacebookService bool update_partition_column_statistics(1:ColumnStatistics stats_obj) throws (1:NoSuchObjectException o1, 2:InvalidObjectException o2, 3:MetaException o3, 4:InvalidInputException o4) + SetPartitionsStatsResponse update_table_column_statistics_req(1:SetPartitionsStatsRequest req) throws (1:NoSuchObjectException o1, + 2:InvalidObjectException o2, 3:MetaException o3, 4:InvalidInputException o4) + SetPartitionsStatsResponse update_partition_column_statistics_req(1:SetPartitionsStatsRequest req) throws (1:NoSuchObjectException o1, + 2:InvalidObjectException o2, 3:MetaException o3, 4:InvalidInputException o4) + + void update_transaction_statistics(1:UpdateTransactionalStatsRequest req) throws (1:MetaException o1) + + // get APIs return the column statistics corresponding to db_name, tbl_name, [part_name], col_name if // such statistics exists. If the required statistics doesn't exist, get APIs throw NoSuchObjectException // For instance, if get_table_column_statistics is called on a partitioned table for which only @@ -1962,10 +3003,10 @@ service ThriftHiveMetastore extends fb303.FacebookService // delete APIs attempt to delete column statistics, if found, associated with a given db_name, tbl_name, [part_name] // and col_name. If the delete API doesn't find the statistics record in the metastore, throws NoSuchObjectException // Delete API validates the input and if the input is invalid throws InvalidInputException/InvalidObjectException. - bool delete_partition_column_statistics(1:string db_name, 2:string tbl_name, 3:string part_name, 4:string col_name) throws + bool delete_partition_column_statistics(1:string db_name, 2:string tbl_name, 3:string part_name, 4:string col_name, 5:string engine) throws (1:NoSuchObjectException o1, 2:MetaException o2, 3:InvalidObjectException o3, 4:InvalidInputException o4) - bool delete_table_column_statistics(1:string db_name, 2:string tbl_name, 3:string col_name) throws + bool delete_table_column_statistics(1:string db_name, 2:string tbl_name, 3:string col_name, 4:string engine) throws (1:NoSuchObjectException o1, 2:MetaException o2, 3:InvalidObjectException o3, 4:InvalidInputException o4) @@ -2072,6 +3113,7 @@ service ThriftHiveMetastore extends fb303.FacebookService // Transaction and lock management calls // Get just list of open transactions + // Deprecated use get_open_txns_req GetOpenTxnsResponse get_open_txns() // Get list of open transactions with state (open, aborted) GetOpenTxnsInfoResponse get_open_txns_info() @@ -2079,11 +3121,18 @@ service ThriftHiveMetastore extends fb303.FacebookService void abort_txn(1:AbortTxnRequest rqst) throws (1:NoSuchTxnException o1) void abort_txns(1:AbortTxnsRequest rqst) throws (1:NoSuchTxnException o1) void commit_txn(1:CommitTxnRequest rqst) throws (1:NoSuchTxnException o1, 2:TxnAbortedException o2) + i64 get_latest_txnid_in_conflict(1:i64 txnId) throws (1:MetaException o1) void repl_tbl_writeid_state(1: ReplTblWriteIdStateRequest rqst) GetValidWriteIdsResponse get_valid_write_ids(1:GetValidWriteIdsRequest rqst) throws (1:NoSuchTxnException o1, 2:MetaException o2) + void add_write_ids_to_min_history(1:i64 txnId, 2: map writeIds) throws (1:MetaException o2) AllocateTableWriteIdsResponse allocate_table_write_ids(1:AllocateTableWriteIdsRequest rqst) throws (1:NoSuchTxnException o1, 2:TxnAbortedException o2, 3:MetaException o3) + MaxAllocatedTableWriteIdResponse get_max_allocated_table_write_id(1:MaxAllocatedTableWriteIdRequest rqst) + throws (1:MetaException o1) + void seed_write_id(1:SeedTableWriteIdsRequest rqst) + throws (1:MetaException o1) + void seed_txn_id(1:SeedTxnIdRequest rqst) throws (1:MetaException o1) LockResponse lock(1:LockRequest rqst) throws (1:NoSuchTxnException o1, 2:TxnAbortedException o2) LockResponse check_lock(1:CheckLockRequest rqst) throws (1:NoSuchTxnException o1, 2:TxnAbortedException o2, 3:NoSuchLockException o3) @@ -2094,7 +3143,21 @@ service ThriftHiveMetastore extends fb303.FacebookService void compact(1:CompactionRequest rqst) CompactionResponse compact2(1:CompactionRequest rqst) ShowCompactResponse show_compact(1:ShowCompactRequest rqst) + bool submit_for_cleanup(1:CompactionRequest o1, 2:i64 o2, 3:i64 o3) throws (1:MetaException o1) void add_dynamic_partitions(1:AddDynamicPartitions rqst) throws (1:NoSuchTxnException o1, 2:TxnAbortedException o2) + // Deprecated, use find_next_compact2() + OptionalCompactionInfoStruct find_next_compact(1: string workerId) throws(1:MetaException o1) + OptionalCompactionInfoStruct find_next_compact2(1: FindNextCompactRequest rqst) throws(1:MetaException o1) + void update_compactor_state(1: CompactionInfoStruct cr, 2: i64 txn_id) + list find_columns_with_stats(1: CompactionInfoStruct cr) + void mark_cleaned(1:CompactionInfoStruct cr) throws(1:MetaException o1) + void mark_compacted(1: CompactionInfoStruct cr) throws(1:MetaException o1) + void mark_failed(1: CompactionInfoStruct cr) throws(1:MetaException o1) + void mark_refused(1: CompactionInfoStruct cr) throws(1:MetaException o1) + bool update_compaction_metrics_data(1: CompactionMetricsDataStruct data) throws(1:MetaException o1) + void remove_compaction_metrics_data(1: CompactionMetricsDataRequest request) throws(1:MetaException o1) + void set_hadoop_jobid(1: string jobId, 2: i64 cq_id) + GetLatestCommittedCompactionInfoResponse get_latest_committed_compaction_info(1:GetLatestCommittedCompactionInfoRequest rqst) // Notification logging calls NotificationEventResponse get_next_notification(1:NotificationEventRequest rqst) @@ -2102,6 +3165,8 @@ service ThriftHiveMetastore extends fb303.FacebookService NotificationEventsCountResponse get_notification_events_count(1:NotificationEventsCountRequest rqst) FireEventResponse fire_listener_event(1:FireEventRequest rqst) void flushCache() + WriteNotificationLogResponse add_write_notification_log(1:WriteNotificationLogRequest rqst) + WriteNotificationLogBatchResponse add_write_notification_log_in_batch(1:WriteNotificationLogBatchRequest rqst) // Repl Change Management api CmRecycleResponse cm_recycle(1:CmRecycleRequest request) throws(1:MetaException o1) @@ -2169,7 +3234,7 @@ service ThriftHiveMetastore extends fb303.FacebookService // Schema calls void create_ischema(1:ISchema schema) throws(1:AlreadyExistsException o1, - NoSuchObjectException o2, 3:MetaException o3) + 2: NoSuchObjectException o2, 3:MetaException o3) void alter_ischema(1:AlterISchemaRequest rqst) throws(1:NoSuchObjectException o1, 2:MetaException o2) ISchema get_ischema(1:ISchemaName name) throws (1:NoSuchObjectException o1, 2:MetaException o2) @@ -2203,6 +3268,29 @@ service ThriftHiveMetastore extends fb303.FacebookService void add_runtime_stats(1: RuntimeStat stat) throws(1:MetaException o1) list get_runtime_stats(1: GetRuntimeStatsRequest rqst) throws(1:MetaException o1) + + // get_partitions with filter and projectspec + GetPartitionsResponse get_partitions_with_specs(1: GetPartitionsRequest request) throws(1:MetaException o1) + + ScheduledQueryPollResponse scheduled_query_poll(1: ScheduledQueryPollRequest request) throws(1:MetaException o1) + void scheduled_query_maintenance(1: ScheduledQueryMaintenanceRequest request) throws(1:MetaException o1, 2:NoSuchObjectException o2, 3:AlreadyExistsException o3, 4:InvalidInputException o4) + void scheduled_query_progress(1: ScheduledQueryProgressInfo info) throws(1:MetaException o1, 2: InvalidOperationException o2) + ScheduledQuery get_scheduled_query(1: ScheduledQueryKey scheduleKey) throws(1:MetaException o1, 2:NoSuchObjectException o2) + + void add_replication_metrics(1: ReplicationMetricList replicationMetricList) throws(1:MetaException o1) + ReplicationMetricList get_replication_metrics(1: GetReplicationMetricsRequest rqst) throws(1:MetaException o1) + GetOpenTxnsResponse get_open_txns_req(1: GetOpenTxnsRequest getOpenTxnsRequest) + + void create_stored_procedure(1: StoredProcedure proc) throws(1:NoSuchObjectException o1, 2:MetaException o2) + StoredProcedure get_stored_procedure(1: StoredProcedureRequest request) throws (1:MetaException o1, 2:NoSuchObjectException o2) + void drop_stored_procedure(1: StoredProcedureRequest request) throws (1:MetaException o1) + list get_all_stored_procedures(1: ListStoredProcedureRequest request) throws (1:MetaException o1) + + Package find_package(1: GetPackageRequest request) throws (1:MetaException o1, 2:NoSuchObjectException o2) + void add_package(1: AddPackageRequest request) throws (1:MetaException o1) + list get_all_packages(1: ListPackageRequest request) throws (1:MetaException o1) + void drop_package(1: DropPackageRequest request) throws (1:MetaException o1) + list get_all_write_event_info(1: GetAllWriteEventInfoRequest request) throws (1:MetaException o1) } // * Note about the DDL_TIME: When creating or altering a table or a partition, @@ -2229,6 +3317,7 @@ const string META_TABLE_COLUMN_TYPES = "columns.types", const string BUCKET_FIELD_NAME = "bucket_field_name", const string BUCKET_COUNT = "bucket_count", const string FIELD_TO_DIMENSION = "field_to_dimension", +const string IF_PURGE = "ifPurge", const string META_TABLE_NAME = "name", const string META_TABLE_DB = "db", const string META_TABLE_LOCATION = "location", @@ -2239,6 +3328,22 @@ const string FILE_INPUT_FORMAT = "file.inputformat", const string FILE_OUTPUT_FORMAT = "file.outputformat", const string META_TABLE_STORAGE = "storage_handler", const string TABLE_IS_TRANSACTIONAL = "transactional", -const string TABLE_NO_AUTO_COMPACT = "no_auto_compaction", +const string NO_AUTO_COMPACT = "no_auto_compaction", const string TABLE_TRANSACTIONAL_PROPERTIES = "transactional_properties", const string TABLE_BUCKETING_VERSION = "bucketing_version", +const string DRUID_CONFIG_PREFIX = "druid.", +const string JDBC_CONFIG_PREFIX = "hive.sql.", +const string TABLE_IS_CTAS = "created_with_ctas", +const string TABLE_IS_CTLT = "created_with_ctlt", +const string PARTITION_TRANSFORM_SPEC = "partition_transform_spec", +const string NO_CLEANUP = "no_cleanup", +const string CTAS_LEGACY_CONFIG = "create_table_as_external", +const string DEFAULT_TABLE_TYPE = "defaultTableType", + +// ACID +const string TXN_ID = "txnId", +const string WRITE_ID = "writeId", + +// Keys for alter table environment context parameters +const string EXPECTED_PARAMETER_KEY = "expected_parameter_key", +const string EXPECTED_PARAMETER_VALUE = "expected_parameter_value", From cc4f83e80150cb933041279e7edf3545d2f1b6d1 Mon Sep 17 00:00:00 2001 From: MisterRaindrop <278811821@qq.com> Date: Tue, 16 Jun 2026 10:47:38 +0800 Subject: [PATCH 2/2] ci: skip generated Hive bindings in cpp-linter --- .github/workflows/cpp-linter.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/cpp-linter.yml b/.github/workflows/cpp-linter.yml index 4225d662e..50f5228df 100644 --- a/.github/workflows/cpp-linter.yml +++ b/.github/workflows/cpp-linter.yml @@ -68,7 +68,7 @@ jobs: files-changed-only: true lines-changed-only: true thread-comments: true - ignore: 'build|cmake_modules|ci' + ignore: 'build|cmake_modules|ci|src/iceberg/catalog/hive/gen-cpp' database: build verbosity: 'debug' # need '-fno-builtin-std-forward_like', see https://github.com/llvm/llvm-project/issues/101614