standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_types.h

/**
 * Autogenerated by Thrift Compiler (0.13.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 <iosfwd>

#include <thrift/Thrift.h>
#include <thrift/TApplicationException.h>
#include <thrift/TBase.h>
#include <thrift/protocol/TProtocol.h>
#include <thrift/transport/TTransport.h>

#include <functional>
#include <memory>
#include "fb303_types.h"


namespace Apache { namespace Hadoop { namespace Hive {

struct HiveObjectType {
  enum type {
    GLOBAL = 1,
    DATABASE = 2,
    TABLE = 3,
    PARTITION = 4,
    COLUMN = 5
  };
};

extern const std::map<int, const char*> _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<int, const char*> _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<int, const char*> _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<int, const char*> _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<int, const char*> _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<int, const char*> _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<int, const char*> _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
  };
};

extern const std::map<int, const char*> _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<int, const char*> _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<int, const char*> _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<int, const char*> _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<int, const char*> _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<int, const char*> _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<int, const char*> _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<int, const char*> _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<int, const char*> _SchemaVersionState_VALUES_TO_NAMES;

std::ostream& operator<<(std::ostream& out, const SchemaVersionState::type& val);

std::string to_string(const SchemaVersionState::type& val);

struct FunctionType {
  enum type {
    JAVA = 1
  };
};

extern const std::map<int, const char*> _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<int, const char*> _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
  };
};

extern const std::map<int, const char*> _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<int, const char*> _GetTablesExtRequestFields_VALUES_TO_NAMES;

std::ostream& operator<<(std::ostream& out, const GetTablesExtRequestFields::type& val);

std::string to_string(const GetTablesExtRequestFields::type& val);

struct FileMetadataExprType {
  enum type {
    ORC_SARG = 1
  };
};

extern const std::map<int, const char*> _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<int, const char*> _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<int, const char*> _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<int, const char*> _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<int, const char*> _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
  };
};

extern const std::map<int, const char*> _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<int, const char*> _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 SQLPrimaryKey;

class SQLForeignKey;

class SQLUniqueConstraint;

class SQLNotNullConstraint;

class SQLDefaultConstraint;

class SQLCheckConstraint;

class SQLAllTableConstraints;

class Type;

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 Table;

class Partition;

class PartitionWithoutSD;

class PartitionSpecWithSharedSD;

class PartitionListComposingSpec;

class PartitionSpec;

class AggrStats;

class SetPartitionsStatsRequest;

class SetPartitionsStatsResponse;

class Schema;

class EnvironmentContext;

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 PartitionValuesRequest;

class PartitionValuesRow;

class PartitionValuesResponse;

class GetPartitionsByNamesRequest;

class GetPartitionsByNamesResult;

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 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 CompactionResponse;

class ShowCompactRequest;

class ShowCompactResponseElement;

class ShowCompactResponse;

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 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 GetDatabaseRequest;

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 ScheduledQueryPollRequest;

class ScheduledQueryKey;

class ScheduledQueryPollResponse;

class ScheduledQuery;

class ScheduledQueryMaintenanceRequest;

class ScheduledQueryProgressInfo;

class AlterPartitionsRequest;

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 GetPartitionNamesPsRequest;

class GetPartitionNamesPsResponse;

class GetPartitionsPsWithAuthRequest;

class GetPartitionsPsWithAuthResponse;

class ReplicationMetrics;

class ReplicationMetricList;

class GetReplicationMetricsRequest;

class GetOpenTxnsRequest;

class StoredProcedureRequest;

class ListStoredProcedureRequest;

class StoredProcedure;

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;

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() : version(), comments() {
  }

  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
  {
    if (!(version == rhs.version))
      return false;
    if (!(comments == rhs.comments))
      return false;
    return true;
  }
  bool operator != (const Version &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Version & ) 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;
};

void swap(Version &a, Version &b);

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() : name(), type(), comment() {
  }

  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
  {
    if (!(name == rhs.name))
      return false;
    if (!(type == rhs.type))
      return false;
    if (!(comment == rhs.comment))
      return false;
    return true;
  }
  bool operator != (const FieldSchema &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const FieldSchema & ) 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;
};

void swap(FieldSchema &a, FieldSchema &b);

std::ostream& operator<<(std::ostream& out, const FieldSchema& 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() : table_db(), table_name(), column_name(), key_seq(0), pk_name(), enable_cstr(0), validate_cstr(0), rely_cstr(0), catName() {
  }

  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
  {
    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;
  }
  bool operator != (const SQLPrimaryKey &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const SQLPrimaryKey & ) 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;
};

void swap(SQLPrimaryKey &a, SQLPrimaryKey &b);

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() : 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() {
  }

  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
  {
    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;
  }
  bool operator != (const SQLForeignKey &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const SQLForeignKey & ) 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;
};

void swap(SQLForeignKey &a, SQLForeignKey &b);

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() : catName(), table_db(), table_name(), column_name(), key_seq(0), uk_name(), enable_cstr(0), validate_cstr(0), rely_cstr(0) {
  }

  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
  {
    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;
  }
  bool operator != (const SQLUniqueConstraint &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const SQLUniqueConstraint & ) 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;
};

void swap(SQLUniqueConstraint &a, SQLUniqueConstraint &b);

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() : catName(), table_db(), table_name(), column_name(), nn_name(), enable_cstr(0), validate_cstr(0), rely_cstr(0) {
  }

  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
  {
    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;
  }
  bool operator != (const SQLNotNullConstraint &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const SQLNotNullConstraint & ) 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;
};

void swap(SQLNotNullConstraint &a, SQLNotNullConstraint &b);

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() : catName(), table_db(), table_name(), column_name(), default_value(), dc_name(), enable_cstr(0), validate_cstr(0), rely_cstr(0) {
  }

  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
  {
    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;
  }
  bool operator != (const SQLDefaultConstraint &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const SQLDefaultConstraint & ) 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;
};

void swap(SQLDefaultConstraint &a, SQLDefaultConstraint &b);

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() : catName(), table_db(), table_name(), column_name(), check_expression(), dc_name(), enable_cstr(0), validate_cstr(0), rely_cstr(0) {
  }

  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
  {
    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;
  }
  bool operator != (const SQLCheckConstraint &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const SQLCheckConstraint & ) 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;
};

void swap(SQLCheckConstraint &a, SQLCheckConstraint &b);

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() {
  }

  virtual ~SQLAllTableConstraints() noexcept;
  std::vector<SQLPrimaryKey>  primaryKeys;
  std::vector<SQLForeignKey>  foreignKeys;
  std::vector<SQLUniqueConstraint>  uniqueConstraints;
  std::vector<SQLNotNullConstraint>  notNullConstraints;
  std::vector<SQLDefaultConstraint>  defaultConstraints;
  std::vector<SQLCheckConstraint>  checkConstraints;

  _SQLAllTableConstraints__isset __isset;

  void __set_primaryKeys(const std::vector<SQLPrimaryKey> & val);

  void __set_foreignKeys(const std::vector<SQLForeignKey> & val);

  void __set_uniqueConstraints(const std::vector<SQLUniqueConstraint> & val);

  void __set_notNullConstraints(const std::vector<SQLNotNullConstraint> & val);

  void __set_defaultConstraints(const std::vector<SQLDefaultConstraint> & val);

  void __set_checkConstraints(const std::vector<SQLCheckConstraint> & val);

  bool 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;
  }
  bool operator != (const SQLAllTableConstraints &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const SQLAllTableConstraints & ) 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;
};

void swap(SQLAllTableConstraints &a, SQLAllTableConstraints &b);

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() : name(), type1(), type2() {
  }

  virtual ~Type() noexcept;
  std::string name;
  std::string type1;
  std::string type2;
  std::vector<FieldSchema>  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<FieldSchema> & val);

  bool 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;
  }
  bool operator != (const Type &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Type & ) 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;
};

void swap(Type &a, Type &b);

std::ostream& operator<<(std::ostream& out, const Type& 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() : objectType((HiveObjectType::type)0), dbName(), objectName(), columnName(), catName() {
  }

  virtual ~HiveObjectRef() noexcept;
  HiveObjectType::type objectType;
  std::string dbName;
  std::string objectName;
  std::vector<std::string>  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<std::string> & val);

  void __set_columnName(const std::string& val);

  void __set_catName(const std::string& val);

  bool 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;
  }
  bool operator != (const HiveObjectRef &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const HiveObjectRef & ) 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;
};

void swap(HiveObjectRef &a, HiveObjectRef &b);

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() : privilege(), createTime(0), grantor(), grantorType((PrincipalType::type)0), grantOption(0) {
  }

  virtual ~PrivilegeGrantInfo() noexcept;
  std::string privilege;
  int32_t createTime;
  std::string grantor;
  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
  {
    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;
  }
  bool operator != (const PrivilegeGrantInfo &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const PrivilegeGrantInfo & ) 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;
};

void swap(PrivilegeGrantInfo &a, PrivilegeGrantInfo &b);

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() : principalName(), principalType((PrincipalType::type)0), authorizer() {
  }

  virtual ~HiveObjectPrivilege() noexcept;
  HiveObjectRef hiveObject;
  std::string principalName;
  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
  {
    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;
  }
  bool operator != (const HiveObjectPrivilege &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const HiveObjectPrivilege & ) 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;
};

void swap(HiveObjectPrivilege &a, HiveObjectPrivilege &b);

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() {
  }

  virtual ~PrivilegeBag() noexcept;
  std::vector<HiveObjectPrivilege>  privileges;

  _PrivilegeBag__isset __isset;

  void __set_privileges(const std::vector<HiveObjectPrivilege> & val);

  bool operator == (const PrivilegeBag & rhs) const
  {
    if (!(privileges == rhs.privileges))
      return false;
    return true;
  }
  bool operator != (const PrivilegeBag &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const PrivilegeBag & ) 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;
};

void swap(PrivilegeBag &a, PrivilegeBag &b);

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() {
  }

  virtual ~PrincipalPrivilegeSet() noexcept;
  std::map<std::string, std::vector<PrivilegeGrantInfo> >  userPrivileges;
  std::map<std::string, std::vector<PrivilegeGrantInfo> >  groupPrivileges;
  std::map<std::string, std::vector<PrivilegeGrantInfo> >  rolePrivileges;

  _PrincipalPrivilegeSet__isset __isset;

  void __set_userPrivileges(const std::map<std::string, std::vector<PrivilegeGrantInfo> > & val);

  void __set_groupPrivileges(const std::map<std::string, std::vector<PrivilegeGrantInfo> > & val);

  void __set_rolePrivileges(const std::map<std::string, std::vector<PrivilegeGrantInfo> > & val);

  bool 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;
  }
  bool operator != (const PrincipalPrivilegeSet &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const PrincipalPrivilegeSet & ) 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;
};

void swap(PrincipalPrivilegeSet &a, PrincipalPrivilegeSet &b);

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() : requestType((GrantRevokeType::type)0), revokeGrantOption(0) {
  }

  virtual ~GrantRevokePrivilegeRequest() noexcept;
  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
  {
    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;
  }
  bool operator != (const GrantRevokePrivilegeRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GrantRevokePrivilegeRequest & ) 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;
};

void swap(GrantRevokePrivilegeRequest &a, GrantRevokePrivilegeRequest &b);

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&);
  GrantRevokePrivilegeResponse& operator=(const GrantRevokePrivilegeResponse&);
  GrantRevokePrivilegeResponse() : success(0) {
  }

  virtual ~GrantRevokePrivilegeResponse() noexcept;
  bool success;

  _GrantRevokePrivilegeResponse__isset __isset;

  void __set_success(const bool val);

  bool operator == (const GrantRevokePrivilegeResponse & rhs) const
  {
    if (__isset.success != rhs.__isset.success)
      return false;
    else if (__isset.success && !(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const GrantRevokePrivilegeResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GrantRevokePrivilegeResponse & ) 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;
};

void swap(GrantRevokePrivilegeResponse &a, GrantRevokePrivilegeResponse &b);

std::ostream& operator<<(std::ostream& out, const GrantRevokePrivilegeResponse& obj);

typedef struct _TruncateTableRequest__isset {
  _TruncateTableRequest__isset() : partNames(false), writeId(true), validWriteIdList(false) {}
  bool partNames :1;
  bool writeId :1;
  bool validWriteIdList :1;
} _TruncateTableRequest__isset;

class TruncateTableRequest : public virtual ::apache::thrift::TBase {
 public:

  TruncateTableRequest(const TruncateTableRequest&);
  TruncateTableRequest& operator=(const TruncateTableRequest&);
  TruncateTableRequest() : dbName(), tableName(), writeId(-1LL), validWriteIdList() {
  }

  virtual ~TruncateTableRequest() noexcept;
  std::string dbName;
  std::string tableName;
  std::vector<std::string>  partNames;
  int64_t writeId;
  std::string validWriteIdList;

  _TruncateTableRequest__isset __isset;

  void __set_dbName(const std::string& val);

  void __set_tableName(const std::string& val);

  void __set_partNames(const std::vector<std::string> & val);

  void __set_writeId(const int64_t val);

  void __set_validWriteIdList(const std::string& val);

  bool 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;
    return true;
  }
  bool operator != (const TruncateTableRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TruncateTableRequest & ) 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;
};

void swap(TruncateTableRequest &a, TruncateTableRequest &b);

std::ostream& operator<<(std::ostream& out, const TruncateTableRequest& obj);


class TruncateTableResponse : public virtual ::apache::thrift::TBase {
 public:

  TruncateTableResponse(const TruncateTableResponse&);
  TruncateTableResponse& operator=(const TruncateTableResponse&);
  TruncateTableResponse() {
  }

  virtual ~TruncateTableResponse() noexcept;

  bool operator == (const TruncateTableResponse & /* rhs */) const
  {
    return true;
  }
  bool operator != (const TruncateTableResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TruncateTableResponse & ) 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;
};

void swap(TruncateTableResponse &a, TruncateTableResponse &b);

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() : roleName(), createTime(0), ownerName() {
  }

  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
  {
    if (!(roleName == rhs.roleName))
      return false;
    if (!(createTime == rhs.createTime))
      return false;
    if (!(ownerName == rhs.ownerName))
      return false;
    return true;
  }
  bool operator != (const Role &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Role & ) 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;
};

void swap(Role &a, Role &b);

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() : roleName(), principalName(), principalType((PrincipalType::type)0), grantOption(0), grantTime(0), grantorName(), grantorPrincipalType((PrincipalType::type)0) {
  }

  virtual ~RolePrincipalGrant() noexcept;
  std::string roleName;
  std::string principalName;
  PrincipalType::type principalType;
  bool grantOption;
  int32_t grantTime;
  std::string grantorName;
  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
  {
    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;
  }
  bool operator != (const RolePrincipalGrant &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const RolePrincipalGrant & ) 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;
};

void swap(RolePrincipalGrant &a, RolePrincipalGrant &b);

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() : principal_name(), principal_type((PrincipalType::type)0) {
  }

  virtual ~GetRoleGrantsForPrincipalRequest() noexcept;
  std::string principal_name;
  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
  {
    if (!(principal_name == rhs.principal_name))
      return false;
    if (!(principal_type == rhs.principal_type))
      return false;
    return true;
  }
  bool operator != (const GetRoleGrantsForPrincipalRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetRoleGrantsForPrincipalRequest & ) 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;
};

void swap(GetRoleGrantsForPrincipalRequest &a, GetRoleGrantsForPrincipalRequest &b);

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() {
  }

  virtual ~GetRoleGrantsForPrincipalResponse() noexcept;
  std::vector<RolePrincipalGrant>  principalGrants;

  void __set_principalGrants(const std::vector<RolePrincipalGrant> & val);

  bool operator == (const GetRoleGrantsForPrincipalResponse & rhs) const
  {
    if (!(principalGrants == rhs.principalGrants))
      return false;
    return true;
  }
  bool operator != (const GetRoleGrantsForPrincipalResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetRoleGrantsForPrincipalResponse & ) 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;
};

void swap(GetRoleGrantsForPrincipalResponse &a, GetRoleGrantsForPrincipalResponse &b);

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() : roleName() {
  }

  virtual ~GetPrincipalsInRoleRequest() noexcept;
  std::string roleName;

  void __set_roleName(const std::string& val);

  bool operator == (const GetPrincipalsInRoleRequest & rhs) const
  {
    if (!(roleName == rhs.roleName))
      return false;
    return true;
  }
  bool operator != (const GetPrincipalsInRoleRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetPrincipalsInRoleRequest & ) 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;
};

void swap(GetPrincipalsInRoleRequest &a, GetPrincipalsInRoleRequest &b);

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() {
  }

  virtual ~GetPrincipalsInRoleResponse() noexcept;
  std::vector<RolePrincipalGrant>  principalGrants;

  void __set_principalGrants(const std::vector<RolePrincipalGrant> & val);

  bool operator == (const GetPrincipalsInRoleResponse & rhs) const
  {
    if (!(principalGrants == rhs.principalGrants))
      return false;
    return true;
  }
  bool operator != (const GetPrincipalsInRoleResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetPrincipalsInRoleResponse & ) 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;
};

void swap(GetPrincipalsInRoleResponse &a, GetPrincipalsInRoleResponse &b);

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() : requestType((GrantRevokeType::type)0), roleName(), principalName(), principalType((PrincipalType::type)0), grantor(), grantorType((PrincipalType::type)0), grantOption(0) {
  }

  virtual ~GrantRevokeRoleRequest() noexcept;
  GrantRevokeType::type requestType;
  std::string roleName;
  std::string principalName;
  PrincipalType::type principalType;
  std::string grantor;
  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
  {
    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;
  }
  bool operator != (const GrantRevokeRoleRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GrantRevokeRoleRequest & ) 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;
};

void swap(GrantRevokeRoleRequest &a, GrantRevokeRoleRequest &b);

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&);
  GrantRevokeRoleResponse& operator=(const GrantRevokeRoleResponse&);
  GrantRevokeRoleResponse() : success(0) {
  }

  virtual ~GrantRevokeRoleResponse() noexcept;
  bool success;

  _GrantRevokeRoleResponse__isset __isset;

  void __set_success(const bool val);

  bool operator == (const GrantRevokeRoleResponse & rhs) const
  {
    if (__isset.success != rhs.__isset.success)
      return false;
    else if (__isset.success && !(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const GrantRevokeRoleResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GrantRevokeRoleResponse & ) 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;
};

void swap(GrantRevokeRoleResponse &a, GrantRevokeRoleResponse &b);

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() : name(), description(), locationUri(), createTime(0) {
  }

  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
  {
    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;
  }
  bool operator != (const Catalog &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Catalog & ) 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;
};

void swap(Catalog &a, Catalog &b);

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() {
  }

  virtual ~CreateCatalogRequest() noexcept;
  Catalog catalog;

  _CreateCatalogRequest__isset __isset;

  void __set_catalog(const Catalog& val);

  bool operator == (const CreateCatalogRequest & rhs) const
  {
    if (!(catalog == rhs.catalog))
      return false;
    return true;
  }
  bool operator != (const CreateCatalogRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const CreateCatalogRequest & ) 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;
};

void swap(CreateCatalogRequest &a, CreateCatalogRequest &b);

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() : name() {
  }

  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
  {
    if (!(name == rhs.name))
      return false;
    if (!(newCat == rhs.newCat))
      return false;
    return true;
  }
  bool operator != (const AlterCatalogRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const AlterCatalogRequest & ) 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;
};

void swap(AlterCatalogRequest &a, AlterCatalogRequest &b);

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() : name() {
  }

  virtual ~GetCatalogRequest() noexcept;
  std::string name;

  _GetCatalogRequest__isset __isset;

  void __set_name(const std::string& val);

  bool operator == (const GetCatalogRequest & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    return true;
  }
  bool operator != (const GetCatalogRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetCatalogRequest & ) 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;
};

void swap(GetCatalogRequest &a, GetCatalogRequest &b);

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() {
  }

  virtual ~GetCatalogResponse() noexcept;
  Catalog catalog;

  _GetCatalogResponse__isset __isset;

  void __set_catalog(const Catalog& val);

  bool operator == (const GetCatalogResponse & rhs) const
  {
    if (!(catalog == rhs.catalog))
      return false;
    return true;
  }
  bool operator != (const GetCatalogResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetCatalogResponse & ) 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;
};

void swap(GetCatalogResponse &a, GetCatalogResponse &b);

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() {
  }

  virtual ~GetCatalogsResponse() noexcept;
  std::vector<std::string>  names;

  _GetCatalogsResponse__isset __isset;

  void __set_names(const std::vector<std::string> & val);

  bool operator == (const GetCatalogsResponse & rhs) const
  {
    if (!(names == rhs.names))
      return false;
    return true;
  }
  bool operator != (const GetCatalogsResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetCatalogsResponse & ) 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;
};

void swap(GetCatalogsResponse &a, GetCatalogsResponse &b);

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() : name() {
  }

  virtual ~DropCatalogRequest() noexcept;
  std::string name;

  _DropCatalogRequest__isset __isset;

  void __set_name(const std::string& val);

  bool operator == (const DropCatalogRequest & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    return true;
  }
  bool operator != (const DropCatalogRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const DropCatalogRequest & ) 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;
};

void swap(DropCatalogRequest &a, DropCatalogRequest &b);

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) {}
  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;
} _Database__isset;

class Database : public virtual ::apache::thrift::TBase {
 public:

  Database(const Database&);
  Database& operator=(const Database&);
  Database() : name(), description(), locationUri(), ownerName(), ownerType((PrincipalType::type)0), catalogName(), createTime(0), managedLocationUri() {
  }

  virtual ~Database() noexcept;
  std::string name;
  std::string description;
  std::string locationUri;
  std::map<std::string, std::string>  parameters;
  PrincipalPrivilegeSet privileges;
  std::string ownerName;
  PrincipalType::type ownerType;
  std::string catalogName;
  int32_t createTime;
  std::string managedLocationUri;

  _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<std::string, std::string> & 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);

  bool 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;
    return true;
  }
  bool operator != (const Database &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Database & ) 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;
};

void swap(Database &a, Database &b);

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() : name(), serializationLib(), description(), serializerClass(), deserializerClass(), serdeType((SerdeType::type)0) {
  }

  virtual ~SerDeInfo() noexcept;
  std::string name;
  std::string serializationLib;
  std::map<std::string, std::string>  parameters;
  std::string description;
  std::string serializerClass;
  std::string deserializerClass;
  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<std::string, std::string> & 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
  {
    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;
  }
  bool operator != (const SerDeInfo &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const SerDeInfo & ) 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;
};

void swap(SerDeInfo &a, SerDeInfo &b);

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() : col(), order(0) {
  }

  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
  {
    if (!(col == rhs.col))
      return false;
    if (!(order == rhs.order))
      return false;
    return true;
  }
  bool operator != (const Order &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Order & ) 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;
};

void swap(Order &a, Order &b);

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() {
  }

  virtual ~SkewedInfo() noexcept;
  std::vector<std::string>  skewedColNames;
  std::vector<std::vector<std::string> >  skewedColValues;
  std::map<std::vector<std::string> , std::string>  skewedColValueLocationMaps;

  _SkewedInfo__isset __isset;

  void __set_skewedColNames(const std::vector<std::string> & val);

  void __set_skewedColValues(const std::vector<std::vector<std::string> > & val);

  void __set_skewedColValueLocationMaps(const std::map<std::vector<std::string> , std::string> & val);

  bool 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;
  }
  bool operator != (const SkewedInfo &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const SkewedInfo & ) 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;
};

void swap(SkewedInfo &a, SkewedInfo &b);

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() : location(), inputFormat(), outputFormat(), compressed(0), numBuckets(0), storedAsSubDirectories(0) {
  }

  virtual ~StorageDescriptor() noexcept;
  std::vector<FieldSchema>  cols;
  std::string location;
  std::string inputFormat;
  std::string outputFormat;
  bool compressed;
  int32_t numBuckets;
  SerDeInfo serdeInfo;
  std::vector<std::string>  bucketCols;
  std::vector<Order>  sortCols;
  std::map<std::string, std::string>  parameters;
  SkewedInfo skewedInfo;
  bool storedAsSubDirectories;

  _StorageDescriptor__isset __isset;

  void __set_cols(const std::vector<FieldSchema> & 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<std::string> & val);

  void __set_sortCols(const std::vector<Order> & val);

  void __set_parameters(const std::map<std::string, std::string> & val);

  void __set_skewedInfo(const SkewedInfo& val);

  void __set_storedAsSubDirectories(const bool val);

  bool 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;
  }
  bool operator != (const StorageDescriptor &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const StorageDescriptor & ) 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;
};

void swap(StorageDescriptor &a, StorageDescriptor &b);

std::ostream& operator<<(std::ostream& out, const StorageDescriptor& obj);

typedef struct _CreationMetadata__isset {
  _CreationMetadata__isset() : validTxnList(false), materializationTime(false) {}
  bool validTxnList :1;
  bool materializationTime :1;
} _CreationMetadata__isset;

class CreationMetadata : public virtual ::apache::thrift::TBase {
 public:

  CreationMetadata(const CreationMetadata&);
  CreationMetadata& operator=(const CreationMetadata&);
  CreationMetadata() : catName(), dbName(), tblName(), validTxnList(), materializationTime(0) {
  }

  virtual ~CreationMetadata() noexcept;
  std::string catName;
  std::string dbName;
  std::string tblName;
  std::set<std::string>  tablesUsed;
  std::string validTxnList;
  int64_t materializationTime;

  _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<std::string> & val);

  void __set_validTxnList(const std::string& val);

  void __set_materializationTime(const int64_t val);

  bool 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;
    return true;
  }
  bool operator != (const CreationMetadata &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const CreationMetadata & ) 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;
};

void swap(CreationMetadata &a, CreationMetadata &b);

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() : numTrues(0), numFalses(0), numNulls(0), bitVectors() {
  }

  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
  {
    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;
  }
  bool operator != (const BooleanColumnStatsData &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const BooleanColumnStatsData & ) 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;
};

void swap(BooleanColumnStatsData &a, BooleanColumnStatsData &b);

std::ostream& operator<<(std::ostream& out, const BooleanColumnStatsData& obj);

typedef struct _DoubleColumnStatsData__isset {
  _DoubleColumnStatsData__isset() : lowValue(false), highValue(false), bitVectors(false) {}
  bool lowValue :1;
  bool highValue :1;
  bool bitVectors :1;
} _DoubleColumnStatsData__isset;

class DoubleColumnStatsData : public virtual ::apache::thrift::TBase {
 public:

  DoubleColumnStatsData(const DoubleColumnStatsData&);
  DoubleColumnStatsData& operator=(const DoubleColumnStatsData&);
  DoubleColumnStatsData() : lowValue(0), highValue(0), numNulls(0), numDVs(0), bitVectors() {
  }

  virtual ~DoubleColumnStatsData() noexcept;
  double lowValue;
  double highValue;
  int64_t numNulls;
  int64_t numDVs;
  std::string bitVectors;

  _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);

  bool 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;
    return true;
  }
  bool operator != (const DoubleColumnStatsData &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const DoubleColumnStatsData & ) 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;
};

void swap(DoubleColumnStatsData &a, DoubleColumnStatsData &b);

std::ostream& operator<<(std::ostream& out, const DoubleColumnStatsData& obj);

typedef struct _LongColumnStatsData__isset {
  _LongColumnStatsData__isset() : lowValue(false), highValue(false), bitVectors(false) {}
  bool lowValue :1;
  bool highValue :1;
  bool bitVectors :1;
} _LongColumnStatsData__isset;

class LongColumnStatsData : public virtual ::apache::thrift::TBase {
 public:

  LongColumnStatsData(const LongColumnStatsData&);
  LongColumnStatsData& operator=(const LongColumnStatsData&);
  LongColumnStatsData() : lowValue(0), highValue(0), numNulls(0), numDVs(0), bitVectors() {
  }

  virtual ~LongColumnStatsData() noexcept;
  int64_t lowValue;
  int64_t highValue;
  int64_t numNulls;
  int64_t numDVs;
  std::string bitVectors;

  _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);

  bool 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;
    return true;
  }
  bool operator != (const LongColumnStatsData &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const LongColumnStatsData & ) 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;
};

void swap(LongColumnStatsData &a, LongColumnStatsData &b);

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() : maxColLen(0), avgColLen(0), numNulls(0), numDVs(0), bitVectors() {
  }

  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
  {
    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;
  }
  bool operator != (const StringColumnStatsData &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const StringColumnStatsData & ) 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;
};

void swap(StringColumnStatsData &a, StringColumnStatsData &b);

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() : maxColLen(0), avgColLen(0), numNulls(0), bitVectors() {
  }

  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
  {
    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;
  }
  bool operator != (const BinaryColumnStatsData &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const BinaryColumnStatsData & ) 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;
};

void swap(BinaryColumnStatsData &a, BinaryColumnStatsData &b);

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() : scale(0), unscaled() {
  }

  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
  {
    if (!(scale == rhs.scale))
      return false;
    if (!(unscaled == rhs.unscaled))
      return false;
    return true;
  }
  bool operator != (const Decimal &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Decimal & ) 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;
};

void swap(Decimal &a, Decimal &b);

std::ostream& operator<<(std::ostream& out, const Decimal& obj);

typedef struct _DecimalColumnStatsData__isset {
  _DecimalColumnStatsData__isset() : lowValue(false), highValue(false), bitVectors(false) {}
  bool lowValue :1;
  bool highValue :1;
  bool bitVectors :1;
} _DecimalColumnStatsData__isset;

class DecimalColumnStatsData : public virtual ::apache::thrift::TBase {
 public:

  DecimalColumnStatsData(const DecimalColumnStatsData&);
  DecimalColumnStatsData& operator=(const DecimalColumnStatsData&);
  DecimalColumnStatsData() : numNulls(0), numDVs(0), bitVectors() {
  }

  virtual ~DecimalColumnStatsData() noexcept;
  Decimal lowValue;
  Decimal highValue;
  int64_t numNulls;
  int64_t numDVs;
  std::string bitVectors;

  _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);

  bool 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;
    return true;
  }
  bool operator != (const DecimalColumnStatsData &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const DecimalColumnStatsData & ) 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;
};

void swap(DecimalColumnStatsData &a, DecimalColumnStatsData &b);

std::ostream& operator<<(std::ostream& out, const DecimalColumnStatsData& obj);


class Date : public virtual ::apache::thrift::TBase {
 public:

  Date(const Date&);
  Date& operator=(const Date&);
  Date() : daysSinceEpoch(0) {
  }

  virtual ~Date() noexcept;
  int64_t daysSinceEpoch;

  void __set_daysSinceEpoch(const int64_t val);

  bool operator == (const Date & rhs) const
  {
    if (!(daysSinceEpoch == rhs.daysSinceEpoch))
      return false;
    return true;
  }
  bool operator != (const Date &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Date & ) 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;
};

void swap(Date &a, Date &b);

std::ostream& operator<<(std::ostream& out, const Date& obj);

typedef struct _DateColumnStatsData__isset {
  _DateColumnStatsData__isset() : lowValue(false), highValue(false), bitVectors(false) {}
  bool lowValue :1;
  bool highValue :1;
  bool bitVectors :1;
} _DateColumnStatsData__isset;

class DateColumnStatsData : public virtual ::apache::thrift::TBase {
 public:

  DateColumnStatsData(const DateColumnStatsData&);
  DateColumnStatsData& operator=(const DateColumnStatsData&);
  DateColumnStatsData() : numNulls(0), numDVs(0), bitVectors() {
  }

  virtual ~DateColumnStatsData() noexcept;
  Date lowValue;
  Date highValue;
  int64_t numNulls;
  int64_t numDVs;
  std::string bitVectors;

  _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);

  bool 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;
    return true;
  }
  bool operator != (const DateColumnStatsData &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const DateColumnStatsData & ) 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;
};

void swap(DateColumnStatsData &a, DateColumnStatsData &b);

std::ostream& operator<<(std::ostream& out, const DateColumnStatsData& obj);


class Timestamp : public virtual ::apache::thrift::TBase {
 public:

  Timestamp(const Timestamp&);
  Timestamp& operator=(const Timestamp&);
  Timestamp() : secondsSinceEpoch(0) {
  }

  virtual ~Timestamp() noexcept;
  int64_t secondsSinceEpoch;

  void __set_secondsSinceEpoch(const int64_t val);

  bool operator == (const Timestamp & rhs) const
  {
    if (!(secondsSinceEpoch == rhs.secondsSinceEpoch))
      return false;
    return true;
  }
  bool operator != (const Timestamp &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Timestamp & ) 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;
};

void swap(Timestamp &a, Timestamp &b);

std::ostream& operator<<(std::ostream& out, const Timestamp& obj);

typedef struct _TimestampColumnStatsData__isset {
  _TimestampColumnStatsData__isset() : lowValue(false), highValue(false), bitVectors(false) {}
  bool lowValue :1;
  bool highValue :1;
  bool bitVectors :1;
} _TimestampColumnStatsData__isset;

class TimestampColumnStatsData : public virtual ::apache::thrift::TBase {
 public:

  TimestampColumnStatsData(const TimestampColumnStatsData&);
  TimestampColumnStatsData& operator=(const TimestampColumnStatsData&);
  TimestampColumnStatsData() : numNulls(0), numDVs(0), bitVectors() {
  }

  virtual ~TimestampColumnStatsData() noexcept;
  Timestamp lowValue;
  Timestamp highValue;
  int64_t numNulls;
  int64_t numDVs;
  std::string bitVectors;

  _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);

  bool 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;
    return true;
  }
  bool operator != (const TimestampColumnStatsData &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TimestampColumnStatsData & ) 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;
};

void swap(TimestampColumnStatsData &a, TimestampColumnStatsData &b);

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() {
  }

  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
  {
    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;
  }
  bool operator != (const ColumnStatisticsData &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ColumnStatisticsData & ) 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;
};

void swap(ColumnStatisticsData &a, ColumnStatisticsData &b);

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() : colName(), colType() {
  }

  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
  {
    if (!(colName == rhs.colName))
      return false;
    if (!(colType == rhs.colType))
      return false;
    if (!(statsData == rhs.statsData))
      return false;
    return true;
  }
  bool operator != (const ColumnStatisticsObj &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ColumnStatisticsObj & ) 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;
};

void swap(ColumnStatisticsObj &a, ColumnStatisticsObj &b);

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() : isTblLevel(0), dbName(), tableName(), partName(), lastAnalyzed(0), catName() {
  }

  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
  {
    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;
  }
  bool operator != (const ColumnStatisticsDesc &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ColumnStatisticsDesc & ) 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;
};

void swap(ColumnStatisticsDesc &a, ColumnStatisticsDesc &b);

std::ostream& operator<<(std::ostream& out, const ColumnStatisticsDesc& obj);

typedef struct _ColumnStatistics__isset {
  _ColumnStatistics__isset() : isStatsCompliant(false), engine(false) {}
  bool isStatsCompliant :1;
  bool engine :1;
} _ColumnStatistics__isset;

class ColumnStatistics : public virtual ::apache::thrift::TBase {
 public:

  ColumnStatistics(const ColumnStatistics&);
  ColumnStatistics& operator=(const ColumnStatistics&);
  ColumnStatistics() : isStatsCompliant(0), engine() {
  }

  virtual ~ColumnStatistics() noexcept;
  ColumnStatisticsDesc statsDesc;
  std::vector<ColumnStatisticsObj>  statsObj;
  bool isStatsCompliant;
  std::string engine;

  _ColumnStatistics__isset __isset;

  void __set_statsDesc(const ColumnStatisticsDesc& val);

  void __set_statsObj(const std::vector<ColumnStatisticsObj> & val);

  void __set_isStatsCompliant(const bool val);

  void __set_engine(const std::string& val);

  bool 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;
  }
  bool operator != (const ColumnStatistics &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ColumnStatistics & ) 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;
};

void swap(ColumnStatistics &a, ColumnStatistics &b);

std::ostream& operator<<(std::ostream& out, const ColumnStatistics& 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) {}
  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;
} _Table__isset;

class Table : public virtual ::apache::thrift::TBase {
 public:

  Table(const Table&);
  Table& operator=(const Table&);
  Table() : tableName(), dbName(), owner(), createTime(0), lastAccessTime(0), retention(0), viewOriginalText(), viewExpandedText(), tableType(), temporary(false), rewriteEnabled(0), catName(), ownerType((PrincipalType::type)1), writeId(-1LL), isStatsCompliant(0), accessType(0), id(0) {
    ownerType = (PrincipalType::type)1;

  }

  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<FieldSchema>  partitionKeys;
  std::map<std::string, std::string>  parameters;
  std::string viewOriginalText;
  std::string viewExpandedText;
  std::string tableType;
  PrincipalPrivilegeSet privileges;
  bool temporary;
  bool rewriteEnabled;
  CreationMetadata creationMetadata;
  std::string catName;
  PrincipalType::type ownerType;
  int64_t writeId;
  bool isStatsCompliant;
  ColumnStatistics colStats;
  int8_t accessType;
  std::vector<std::string>  requiredReadCapabilities;
  std::vector<std::string>  requiredWriteCapabilities;
  int64_t id;

  _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<FieldSchema> & val);

  void __set_parameters(const std::map<std::string, std::string> & 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<std::string> & val);

  void __set_requiredWriteCapabilities(const std::vector<std::string> & val);

  void __set_id(const int64_t val);

  bool 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;
    return true;
  }
  bool operator != (const Table &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Table & ) 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;
};

void swap(Table &a, Table &b);

std::ostream& operator<<(std::ostream& out, const Table& 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) {}
  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;
} _Partition__isset;

class Partition : public virtual ::apache::thrift::TBase {
 public:

  Partition(const Partition&);
  Partition& operator=(const Partition&);
  Partition() : dbName(), tableName(), createTime(0), lastAccessTime(0), catName(), writeId(-1LL), isStatsCompliant(0) {
  }

  virtual ~Partition() noexcept;
  std::vector<std::string>  values;
  std::string dbName;
  std::string tableName;
  int32_t createTime;
  int32_t lastAccessTime;
  StorageDescriptor sd;
  std::map<std::string, std::string>  parameters;
  PrincipalPrivilegeSet privileges;
  std::string catName;
  int64_t writeId;
  bool isStatsCompliant;
  ColumnStatistics colStats;

  _Partition__isset __isset;

  void __set_values(const std::vector<std::string> & 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<std::string, std::string> & 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);

  bool 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;
    return true;
  }
  bool operator != (const Partition &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Partition & ) 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;
};

void swap(Partition &a, Partition &b);

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() : createTime(0), lastAccessTime(0), relativePath() {
  }

  virtual ~PartitionWithoutSD() noexcept;
  std::vector<std::string>  values;
  int32_t createTime;
  int32_t lastAccessTime;
  std::string relativePath;
  std::map<std::string, std::string>  parameters;
  PrincipalPrivilegeSet privileges;

  _PartitionWithoutSD__isset __isset;

  void __set_values(const std::vector<std::string> & 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<std::string, std::string> & val);

  void __set_privileges(const PrincipalPrivilegeSet& val);

  bool 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;
  }
  bool operator != (const PartitionWithoutSD &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const PartitionWithoutSD & ) 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;
};

void swap(PartitionWithoutSD &a, PartitionWithoutSD &b);

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() {
  }

  virtual ~PartitionSpecWithSharedSD() noexcept;
  std::vector<PartitionWithoutSD>  partitions;
  StorageDescriptor sd;

  _PartitionSpecWithSharedSD__isset __isset;

  void __set_partitions(const std::vector<PartitionWithoutSD> & val);

  void __set_sd(const StorageDescriptor& val);

  bool operator == (const PartitionSpecWithSharedSD & rhs) const
  {
    if (!(partitions == rhs.partitions))
      return false;
    if (!(sd == rhs.sd))
      return false;
    return true;
  }
  bool operator != (const PartitionSpecWithSharedSD &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const PartitionSpecWithSharedSD & ) 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;
};

void swap(PartitionSpecWithSharedSD &a, PartitionSpecWithSharedSD &b);

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() {
  }

  virtual ~PartitionListComposingSpec() noexcept;
  std::vector<Partition>  partitions;

  _PartitionListComposingSpec__isset __isset;

  void __set_partitions(const std::vector<Partition> & val);

  bool operator == (const PartitionListComposingSpec & rhs) const
  {
    if (!(partitions == rhs.partitions))
      return false;
    return true;
  }
  bool operator != (const PartitionListComposingSpec &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const PartitionListComposingSpec & ) 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;
};

void swap(PartitionListComposingSpec &a, PartitionListComposingSpec &b);

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() : dbName(), tableName(), rootPath(), catName(), writeId(-1LL), isStatsCompliant(0) {
  }

  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
  {
    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;
  }
  bool operator != (const PartitionSpec &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const PartitionSpec & ) 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;
};

void swap(PartitionSpec &a, PartitionSpec &b);

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() : partsFound(0), isStatsCompliant(0) {
  }

  virtual ~AggrStats() noexcept;
  std::vector<ColumnStatisticsObj>  colStats;
  int64_t partsFound;
  bool isStatsCompliant;

  _AggrStats__isset __isset;

  void __set_colStats(const std::vector<ColumnStatisticsObj> & val);

  void __set_partsFound(const int64_t val);

  void __set_isStatsCompliant(const bool val);

  bool 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;
  }
  bool operator != (const AggrStats &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const AggrStats & ) 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;
};

void swap(AggrStats &a, AggrStats &b);

std::ostream& operator<<(std::ostream& out, const AggrStats& obj);

typedef struct _SetPartitionsStatsRequest__isset {
  _SetPartitionsStatsRequest__isset() : needMerge(false), writeId(true), validWriteIdList(false) {}
  bool needMerge :1;
  bool writeId :1;
  bool validWriteIdList :1;
} _SetPartitionsStatsRequest__isset;

class SetPartitionsStatsRequest : public virtual ::apache::thrift::TBase {
 public:

  SetPartitionsStatsRequest(const SetPartitionsStatsRequest&);
  SetPartitionsStatsRequest& operator=(const SetPartitionsStatsRequest&);
  SetPartitionsStatsRequest() : needMerge(0), writeId(-1LL), validWriteIdList(), engine() {
  }

  virtual ~SetPartitionsStatsRequest() noexcept;
  std::vector<ColumnStatistics>  colStats;
  bool needMerge;
  int64_t writeId;
  std::string validWriteIdList;
  std::string engine;

  _SetPartitionsStatsRequest__isset __isset;

  void __set_colStats(const std::vector<ColumnStatistics> & 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
  {
    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 (!(engine == rhs.engine))
      return false;
    return true;
  }
  bool operator != (const SetPartitionsStatsRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const SetPartitionsStatsRequest & ) 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;
};

void swap(SetPartitionsStatsRequest &a, SetPartitionsStatsRequest &b);

std::ostream& operator<<(std::ostream& out, const SetPartitionsStatsRequest& obj);


class SetPartitionsStatsResponse : public virtual ::apache::thrift::TBase {
 public:

  SetPartitionsStatsResponse(const SetPartitionsStatsResponse&);
  SetPartitionsStatsResponse& operator=(const SetPartitionsStatsResponse&);
  SetPartitionsStatsResponse() : result(0) {
  }

  virtual ~SetPartitionsStatsResponse() noexcept;
  bool result;

  void __set_result(const bool val);

  bool operator == (const SetPartitionsStatsResponse & rhs) const
  {
    if (!(result == rhs.result))
      return false;
    return true;
  }
  bool operator != (const SetPartitionsStatsResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const SetPartitionsStatsResponse & ) 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;
};

void swap(SetPartitionsStatsResponse &a, SetPartitionsStatsResponse &b);

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() {
  }

  virtual ~Schema() noexcept;
  std::vector<FieldSchema>  fieldSchemas;
  std::map<std::string, std::string>  properties;

  _Schema__isset __isset;

  void __set_fieldSchemas(const std::vector<FieldSchema> & val);

  void __set_properties(const std::map<std::string, std::string> & val);

  bool operator == (const Schema & rhs) const
  {
    if (!(fieldSchemas == rhs.fieldSchemas))
      return false;
    if (!(properties == rhs.properties))
      return false;
    return true;
  }
  bool operator != (const Schema &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Schema & ) 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;
};

void swap(Schema &a, Schema &b);

std::ostream& operator<<(std::ostream& out, const Schema& 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() {
  }

  virtual ~EnvironmentContext() noexcept;
  std::map<std::string, std::string>  properties;

  _EnvironmentContext__isset __isset;

  void __set_properties(const std::map<std::string, std::string> & val);

  bool operator == (const EnvironmentContext & rhs) const
  {
    if (!(properties == rhs.properties))
      return false;
    return true;
  }
  bool operator != (const EnvironmentContext &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const EnvironmentContext & ) 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;
};

void swap(EnvironmentContext &a, EnvironmentContext &b);

std::ostream& operator<<(std::ostream& out, const EnvironmentContext& obj);

typedef struct _PrimaryKeysRequest__isset {
  _PrimaryKeysRequest__isset() : catName(false) {}
  bool catName :1;
} _PrimaryKeysRequest__isset;

class PrimaryKeysRequest : public virtual ::apache::thrift::TBase {
 public:

  PrimaryKeysRequest(const PrimaryKeysRequest&);
  PrimaryKeysRequest& operator=(const PrimaryKeysRequest&);
  PrimaryKeysRequest() : db_name(), tbl_name(), catName() {
  }

  virtual ~PrimaryKeysRequest() noexcept;
  std::string db_name;
  std::string tbl_name;
  std::string catName;

  _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);

  bool 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;
    return true;
  }
  bool operator != (const PrimaryKeysRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const PrimaryKeysRequest & ) 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;
};

void swap(PrimaryKeysRequest &a, PrimaryKeysRequest &b);

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() {
  }

  virtual ~PrimaryKeysResponse() noexcept;
  std::vector<SQLPrimaryKey>  primaryKeys;

  void __set_primaryKeys(const std::vector<SQLPrimaryKey> & val);

  bool operator == (const PrimaryKeysResponse & rhs) const
  {
    if (!(primaryKeys == rhs.primaryKeys))
      return false;
    return true;
  }
  bool operator != (const PrimaryKeysResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const PrimaryKeysResponse & ) 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;
};

void swap(PrimaryKeysResponse &a, PrimaryKeysResponse &b);

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) {}
  bool parent_db_name :1;
  bool parent_tbl_name :1;
  bool foreign_db_name :1;
  bool foreign_tbl_name :1;
  bool catName :1;
} _ForeignKeysRequest__isset;

class ForeignKeysRequest : public virtual ::apache::thrift::TBase {
 public:

  ForeignKeysRequest(const ForeignKeysRequest&);
  ForeignKeysRequest& operator=(const ForeignKeysRequest&);
  ForeignKeysRequest() : parent_db_name(), parent_tbl_name(), foreign_db_name(), foreign_tbl_name(), catName() {
  }

  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;

  _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);

  bool 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;
    return true;
  }
  bool operator != (const ForeignKeysRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ForeignKeysRequest & ) 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;
};

void swap(ForeignKeysRequest &a, ForeignKeysRequest &b);

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() {
  }

  virtual ~ForeignKeysResponse() noexcept;
  std::vector<SQLForeignKey>  foreignKeys;

  void __set_foreignKeys(const std::vector<SQLForeignKey> & val);

  bool operator == (const ForeignKeysResponse & rhs) const
  {
    if (!(foreignKeys == rhs.foreignKeys))
      return false;
    return true;
  }
  bool operator != (const ForeignKeysResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ForeignKeysResponse & ) 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;
};

void swap(ForeignKeysResponse &a, ForeignKeysResponse &b);

std::ostream& operator<<(std::ostream& out, const ForeignKeysResponse& obj);


class UniqueConstraintsRequest : public virtual ::apache::thrift::TBase {
 public:

  UniqueConstraintsRequest(const UniqueConstraintsRequest&);
  UniqueConstraintsRequest& operator=(const UniqueConstraintsRequest&);
  UniqueConstraintsRequest() : catName(), db_name(), tbl_name() {
  }

  virtual ~UniqueConstraintsRequest() noexcept;
  std::string catName;
  std::string db_name;
  std::string tbl_name;

  void __set_catName(const std::string& val);

  void __set_db_name(const std::string& val);

  void __set_tbl_name(const std::string& val);

  bool 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;
    return true;
  }
  bool operator != (const UniqueConstraintsRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const UniqueConstraintsRequest & ) 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;
};

void swap(UniqueConstraintsRequest &a, UniqueConstraintsRequest &b);

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() {
  }

  virtual ~UniqueConstraintsResponse() noexcept;
  std::vector<SQLUniqueConstraint>  uniqueConstraints;

  void __set_uniqueConstraints(const std::vector<SQLUniqueConstraint> & val);

  bool operator == (const UniqueConstraintsResponse & rhs) const
  {
    if (!(uniqueConstraints == rhs.uniqueConstraints))
      return false;
    return true;
  }
  bool operator != (const UniqueConstraintsResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const UniqueConstraintsResponse & ) 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;
};

void swap(UniqueConstraintsResponse &a, UniqueConstraintsResponse &b);

std::ostream& operator<<(std::ostream& out, const UniqueConstraintsResponse& obj);


class NotNullConstraintsRequest : public virtual ::apache::thrift::TBase {
 public:

  NotNullConstraintsRequest(const NotNullConstraintsRequest&);
  NotNullConstraintsRequest& operator=(const NotNullConstraintsRequest&);
  NotNullConstraintsRequest() : catName(), db_name(), tbl_name() {
  }

  virtual ~NotNullConstraintsRequest() noexcept;
  std::string catName;
  std::string db_name;
  std::string tbl_name;

  void __set_catName(const std::string& val);

  void __set_db_name(const std::string& val);

  void __set_tbl_name(const std::string& val);

  bool 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;
    return true;
  }
  bool operator != (const NotNullConstraintsRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const NotNullConstraintsRequest & ) 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;
};

void swap(NotNullConstraintsRequest &a, NotNullConstraintsRequest &b);

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() {
  }

  virtual ~NotNullConstraintsResponse() noexcept;
  std::vector<SQLNotNullConstraint>  notNullConstraints;

  void __set_notNullConstraints(const std::vector<SQLNotNullConstraint> & val);

  bool operator == (const NotNullConstraintsResponse & rhs) const
  {
    if (!(notNullConstraints == rhs.notNullConstraints))
      return false;
    return true;
  }
  bool operator != (const NotNullConstraintsResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const NotNullConstraintsResponse & ) 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;
};

void swap(NotNullConstraintsResponse &a, NotNullConstraintsResponse &b);

std::ostream& operator<<(std::ostream& out, const NotNullConstraintsResponse& obj);


class DefaultConstraintsRequest : public virtual ::apache::thrift::TBase {
 public:

  DefaultConstraintsRequest(const DefaultConstraintsRequest&);
  DefaultConstraintsRequest& operator=(const DefaultConstraintsRequest&);
  DefaultConstraintsRequest() : catName(), db_name(), tbl_name() {
  }

  virtual ~DefaultConstraintsRequest() noexcept;
  std::string catName;
  std::string db_name;
  std::string tbl_name;

  void __set_catName(const std::string& val);

  void __set_db_name(const std::string& val);

  void __set_tbl_name(const std::string& val);

  bool 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;
    return true;
  }
  bool operator != (const DefaultConstraintsRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const DefaultConstraintsRequest & ) 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;
};

void swap(DefaultConstraintsRequest &a, DefaultConstraintsRequest &b);

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() {
  }

  virtual ~DefaultConstraintsResponse() noexcept;
  std::vector<SQLDefaultConstraint>  defaultConstraints;

  void __set_defaultConstraints(const std::vector<SQLDefaultConstraint> & val);

  bool operator == (const DefaultConstraintsResponse & rhs) const
  {
    if (!(defaultConstraints == rhs.defaultConstraints))
      return false;
    return true;
  }
  bool operator != (const DefaultConstraintsResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const DefaultConstraintsResponse & ) 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;
};

void swap(DefaultConstraintsResponse &a, DefaultConstraintsResponse &b);

std::ostream& operator<<(std::ostream& out, const DefaultConstraintsResponse& obj);


class CheckConstraintsRequest : public virtual ::apache::thrift::TBase {
 public:

  CheckConstraintsRequest(const CheckConstraintsRequest&);
  CheckConstraintsRequest& operator=(const CheckConstraintsRequest&);
  CheckConstraintsRequest() : catName(), db_name(), tbl_name() {
  }

  virtual ~CheckConstraintsRequest() noexcept;
  std::string catName;
  std::string db_name;
  std::string tbl_name;

  void __set_catName(const std::string& val);

  void __set_db_name(const std::string& val);

  void __set_tbl_name(const std::string& val);

  bool 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;
    return true;
  }
  bool operator != (const CheckConstraintsRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const CheckConstraintsRequest & ) 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;
};

void swap(CheckConstraintsRequest &a, CheckConstraintsRequest &b);

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() {
  }

  virtual ~CheckConstraintsResponse() noexcept;
  std::vector<SQLCheckConstraint>  checkConstraints;

  void __set_checkConstraints(const std::vector<SQLCheckConstraint> & val);

  bool operator == (const CheckConstraintsResponse & rhs) const
  {
    if (!(checkConstraints == rhs.checkConstraints))
      return false;
    return true;
  }
  bool operator != (const CheckConstraintsResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const CheckConstraintsResponse & ) 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;
};

void swap(CheckConstraintsResponse &a, CheckConstraintsResponse &b);

std::ostream& operator<<(std::ostream& out, const CheckConstraintsResponse& obj);


class AllTableConstraintsRequest : public virtual ::apache::thrift::TBase {
 public:

  AllTableConstraintsRequest(const AllTableConstraintsRequest&);
  AllTableConstraintsRequest& operator=(const AllTableConstraintsRequest&);
  AllTableConstraintsRequest() : dbName(), tblName(), catName() {
  }

  virtual ~AllTableConstraintsRequest() noexcept;
  std::string dbName;
  std::string tblName;
  std::string catName;

  void __set_dbName(const std::string& val);

  void __set_tblName(const std::string& val);

  void __set_catName(const std::string& val);

  bool operator == (const AllTableConstraintsRequest & rhs) const
  {
    if (!(dbName == rhs.dbName))
      return false;
    if (!(tblName == rhs.tblName))
      return false;
    if (!(catName == rhs.catName))
      return false;
    return true;
  }
  bool operator != (const AllTableConstraintsRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const AllTableConstraintsRequest & ) 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;
};

void swap(AllTableConstraintsRequest &a, AllTableConstraintsRequest &b);

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() {
  }

  virtual ~AllTableConstraintsResponse() noexcept;
  SQLAllTableConstraints allTableConstraints;

  void __set_allTableConstraints(const SQLAllTableConstraints& val);

  bool operator == (const AllTableConstraintsResponse & rhs) const
  {
    if (!(allTableConstraints == rhs.allTableConstraints))
      return false;
    return true;
  }
  bool operator != (const AllTableConstraintsResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const AllTableConstraintsResponse & ) 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;
};

void swap(AllTableConstraintsResponse &a, AllTableConstraintsResponse &b);

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() : dbname(), tablename(), constraintname(), catName() {
  }

  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
  {
    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;
  }
  bool operator != (const DropConstraintRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const DropConstraintRequest & ) 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;
};

void swap(DropConstraintRequest &a, DropConstraintRequest &b);

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() {
  }

  virtual ~AddPrimaryKeyRequest() noexcept;
  std::vector<SQLPrimaryKey>  primaryKeyCols;

  void __set_primaryKeyCols(const std::vector<SQLPrimaryKey> & val);

  bool operator == (const AddPrimaryKeyRequest & rhs) const
  {
    if (!(primaryKeyCols == rhs.primaryKeyCols))
      return false;
    return true;
  }
  bool operator != (const AddPrimaryKeyRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const AddPrimaryKeyRequest & ) 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;
};

void swap(AddPrimaryKeyRequest &a, AddPrimaryKeyRequest &b);

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() {
  }

  virtual ~AddForeignKeyRequest() noexcept;
  std::vector<SQLForeignKey>  foreignKeyCols;

  void __set_foreignKeyCols(const std::vector<SQLForeignKey> & val);

  bool operator == (const AddForeignKeyRequest & rhs) const
  {
    if (!(foreignKeyCols == rhs.foreignKeyCols))
      return false;
    return true;
  }
  bool operator != (const AddForeignKeyRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const AddForeignKeyRequest & ) 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;
};

void swap(AddForeignKeyRequest &a, AddForeignKeyRequest &b);

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() {
  }

  virtual ~AddUniqueConstraintRequest() noexcept;
  std::vector<SQLUniqueConstraint>  uniqueConstraintCols;

  void __set_uniqueConstraintCols(const std::vector<SQLUniqueConstraint> & val);

  bool operator == (const AddUniqueConstraintRequest & rhs) const
  {
    if (!(uniqueConstraintCols == rhs.uniqueConstraintCols))
      return false;
    return true;
  }
  bool operator != (const AddUniqueConstraintRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const AddUniqueConstraintRequest & ) 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;
};

void swap(AddUniqueConstraintRequest &a, AddUniqueConstraintRequest &b);

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() {
  }

  virtual ~AddNotNullConstraintRequest() noexcept;
  std::vector<SQLNotNullConstraint>  notNullConstraintCols;

  void __set_notNullConstraintCols(const std::vector<SQLNotNullConstraint> & val);

  bool operator == (const AddNotNullConstraintRequest & rhs) const
  {
    if (!(notNullConstraintCols == rhs.notNullConstraintCols))
      return false;
    return true;
  }
  bool operator != (const AddNotNullConstraintRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const AddNotNullConstraintRequest & ) 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;
};

void swap(AddNotNullConstraintRequest &a, AddNotNullConstraintRequest &b);

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() {
  }

  virtual ~AddDefaultConstraintRequest() noexcept;
  std::vector<SQLDefaultConstraint>  defaultConstraintCols;

  void __set_defaultConstraintCols(const std::vector<SQLDefaultConstraint> & val);

  bool operator == (const AddDefaultConstraintRequest & rhs) const
  {
    if (!(defaultConstraintCols == rhs.defaultConstraintCols))
      return false;
    return true;
  }
  bool operator != (const AddDefaultConstraintRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const AddDefaultConstraintRequest & ) 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;
};

void swap(AddDefaultConstraintRequest &a, AddDefaultConstraintRequest &b);

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() {
  }

  virtual ~AddCheckConstraintRequest() noexcept;
  std::vector<SQLCheckConstraint>  checkConstraintCols;

  void __set_checkConstraintCols(const std::vector<SQLCheckConstraint> & val);

  bool operator == (const AddCheckConstraintRequest & rhs) const
  {
    if (!(checkConstraintCols == rhs.checkConstraintCols))
      return false;
    return true;
  }
  bool operator != (const AddCheckConstraintRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const AddCheckConstraintRequest & ) 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;
};

void swap(AddCheckConstraintRequest &a, AddCheckConstraintRequest &b);

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() : hasUnknownPartitions(0) {
  }

  virtual ~PartitionsByExprResult() noexcept;
  std::vector<Partition>  partitions;
  bool hasUnknownPartitions;

  void __set_partitions(const std::vector<Partition> & val);

  void __set_hasUnknownPartitions(const bool val);

  bool operator == (const PartitionsByExprResult & rhs) const
  {
    if (!(partitions == rhs.partitions))
      return false;
    if (!(hasUnknownPartitions == rhs.hasUnknownPartitions))
      return false;
    return true;
  }
  bool operator != (const PartitionsByExprResult &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const PartitionsByExprResult & ) 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;
};

void swap(PartitionsByExprResult &a, PartitionsByExprResult &b);

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() : hasUnknownPartitions(0) {
  }

  virtual ~PartitionsSpecByExprResult() noexcept;
  std::vector<PartitionSpec>  partitionsSpec;
  bool hasUnknownPartitions;

  void __set_partitionsSpec(const std::vector<PartitionSpec> & val);

  void __set_hasUnknownPartitions(const bool val);

  bool operator == (const PartitionsSpecByExprResult & rhs) const
  {
    if (!(partitionsSpec == rhs.partitionsSpec))
      return false;
    if (!(hasUnknownPartitions == rhs.hasUnknownPartitions))
      return false;
    return true;
  }
  bool operator != (const PartitionsSpecByExprResult &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const PartitionsSpecByExprResult & ) 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;
};

void swap(PartitionsSpecByExprResult &a, PartitionsSpecByExprResult &b);

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) {}
  bool defaultPartitionName :1;
  bool maxParts :1;
  bool catName :1;
  bool order :1;
  bool validWriteIdList :1;
  bool id :1;
} _PartitionsByExprRequest__isset;

class PartitionsByExprRequest : public virtual ::apache::thrift::TBase {
 public:

  PartitionsByExprRequest(const PartitionsByExprRequest&);
  PartitionsByExprRequest& operator=(const PartitionsByExprRequest&);
  PartitionsByExprRequest() : dbName(), tblName(), expr(), defaultPartitionName(), maxParts(-1), catName(), order(), validWriteIdList(), id(-1LL) {
  }

  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;

  _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);

  bool 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;
    return true;
  }
  bool operator != (const PartitionsByExprRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const PartitionsByExprRequest & ) 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;
};

void swap(PartitionsByExprRequest &a, PartitionsByExprRequest &b);

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() : isStatsCompliant(0) {
  }

  virtual ~TableStatsResult() noexcept;
  std::vector<ColumnStatisticsObj>  tableStats;
  bool isStatsCompliant;

  _TableStatsResult__isset __isset;

  void __set_tableStats(const std::vector<ColumnStatisticsObj> & val);

  void __set_isStatsCompliant(const bool val);

  bool 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;
  }
  bool operator != (const TableStatsResult &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TableStatsResult & ) 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;
};

void swap(TableStatsResult &a, TableStatsResult &b);

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() : isStatsCompliant(0) {
  }

  virtual ~PartitionsStatsResult() noexcept;
  std::map<std::string, std::vector<ColumnStatisticsObj> >  partStats;
  bool isStatsCompliant;

  _PartitionsStatsResult__isset __isset;

  void __set_partStats(const std::map<std::string, std::vector<ColumnStatisticsObj> > & val);

  void __set_isStatsCompliant(const bool val);

  bool 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;
  }
  bool operator != (const PartitionsStatsResult &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const PartitionsStatsResult & ) 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;
};

void swap(PartitionsStatsResult &a, PartitionsStatsResult &b);

std::ostream& operator<<(std::ostream& out, const PartitionsStatsResult& obj);

typedef struct _TableStatsRequest__isset {
  _TableStatsRequest__isset() : catName(false), validWriteIdList(false), id(true) {}
  bool catName :1;
  bool validWriteIdList :1;
  bool id :1;
} _TableStatsRequest__isset;

class TableStatsRequest : public virtual ::apache::thrift::TBase {
 public:

  TableStatsRequest(const TableStatsRequest&);
  TableStatsRequest& operator=(const TableStatsRequest&);
  TableStatsRequest() : dbName(), tblName(), catName(), validWriteIdList(), engine(), id(-1LL) {
  }

  virtual ~TableStatsRequest() noexcept;
  std::string dbName;
  std::string tblName;
  std::vector<std::string>  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<std::string> & 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
  {
    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 (!(engine == rhs.engine))
      return false;
    if (__isset.id != rhs.__isset.id)
      return false;
    else if (__isset.id && !(id == rhs.id))
      return false;
    return true;
  }
  bool operator != (const TableStatsRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TableStatsRequest & ) 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;
};

void swap(TableStatsRequest &a, TableStatsRequest &b);

std::ostream& operator<<(std::ostream& out, const TableStatsRequest& obj);

typedef struct _PartitionsStatsRequest__isset {
  _PartitionsStatsRequest__isset() : catName(false), validWriteIdList(false) {}
  bool catName :1;
  bool validWriteIdList :1;
} _PartitionsStatsRequest__isset;

class PartitionsStatsRequest : public virtual ::apache::thrift::TBase {
 public:

  PartitionsStatsRequest(const PartitionsStatsRequest&);
  PartitionsStatsRequest& operator=(const PartitionsStatsRequest&);
  PartitionsStatsRequest() : dbName(), tblName(), catName(), validWriteIdList(), engine() {
  }

  virtual ~PartitionsStatsRequest() noexcept;
  std::string dbName;
  std::string tblName;
  std::vector<std::string>  colNames;
  std::vector<std::string>  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<std::string> & val);

  void __set_partNames(const std::vector<std::string> & 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
  {
    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 (!(engine == rhs.engine))
      return false;
    return true;
  }
  bool operator != (const PartitionsStatsRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const PartitionsStatsRequest & ) 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;
};

void swap(PartitionsStatsRequest &a, PartitionsStatsRequest &b);

std::ostream& operator<<(std::ostream& out, const PartitionsStatsRequest& obj);

typedef struct _AddPartitionsResult__isset {
  _AddPartitionsResult__isset() : partitions(false), isStatsCompliant(false) {}
  bool partitions :1;
  bool isStatsCompliant :1;
} _AddPartitionsResult__isset;

class AddPartitionsResult : public virtual ::apache::thrift::TBase {
 public:

  AddPartitionsResult(const AddPartitionsResult&);
  AddPartitionsResult& operator=(const AddPartitionsResult&);
  AddPartitionsResult() : isStatsCompliant(0) {
  }

  virtual ~AddPartitionsResult() noexcept;
  std::vector<Partition>  partitions;
  bool isStatsCompliant;

  _AddPartitionsResult__isset __isset;

  void __set_partitions(const std::vector<Partition> & val);

  void __set_isStatsCompliant(const bool val);

  bool 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;
    return true;
  }
  bool operator != (const AddPartitionsResult &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const AddPartitionsResult & ) 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;
};

void swap(AddPartitionsResult &a, AddPartitionsResult &b);

std::ostream& operator<<(std::ostream& out, const AddPartitionsResult& obj);

typedef struct _AddPartitionsRequest__isset {
  _AddPartitionsRequest__isset() : needResult(true), catName(false), validWriteIdList(false) {}
  bool needResult :1;
  bool catName :1;
  bool validWriteIdList :1;
} _AddPartitionsRequest__isset;

class AddPartitionsRequest : public virtual ::apache::thrift::TBase {
 public:

  AddPartitionsRequest(const AddPartitionsRequest&);
  AddPartitionsRequest& operator=(const AddPartitionsRequest&);
  AddPartitionsRequest() : dbName(), tblName(), ifNotExists(0), needResult(true), catName(), validWriteIdList() {
  }

  virtual ~AddPartitionsRequest() noexcept;
  std::string dbName;
  std::string tblName;
  std::vector<Partition>  parts;
  bool ifNotExists;
  bool needResult;
  std::string catName;
  std::string validWriteIdList;

  _AddPartitionsRequest__isset __isset;

  void __set_dbName(const std::string& val);

  void __set_tblName(const std::string& val);

  void __set_parts(const std::vector<Partition> & 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);

  bool 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;
    return true;
  }
  bool operator != (const AddPartitionsRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const AddPartitionsRequest & ) 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;
};

void swap(AddPartitionsRequest &a, AddPartitionsRequest &b);

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() {
  }

  virtual ~DropPartitionsResult() noexcept;
  std::vector<Partition>  partitions;

  _DropPartitionsResult__isset __isset;

  void __set_partitions(const std::vector<Partition> & val);

  bool operator == (const DropPartitionsResult & rhs) const
  {
    if (__isset.partitions != rhs.__isset.partitions)
      return false;
    else if (__isset.partitions && !(partitions == rhs.partitions))
      return false;
    return true;
  }
  bool operator != (const DropPartitionsResult &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const DropPartitionsResult & ) 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;
};

void swap(DropPartitionsResult &a, DropPartitionsResult &b);

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() : expr(), partArchiveLevel(0) {
  }

  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
  {
    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;
  }
  bool operator != (const DropPartitionsExpr &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const DropPartitionsExpr & ) 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;
};

void swap(DropPartitionsExpr &a, DropPartitionsExpr &b);

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() {
  }

  virtual ~RequestPartsSpec() noexcept;
  std::vector<std::string>  names;
  std::vector<DropPartitionsExpr>  exprs;

  _RequestPartsSpec__isset __isset;

  void __set_names(const std::vector<std::string> & val);

  void __set_exprs(const std::vector<DropPartitionsExpr> & val);

  bool 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;
  }
  bool operator != (const RequestPartsSpec &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const RequestPartsSpec & ) 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;
};

void swap(RequestPartsSpec &a, RequestPartsSpec &b);

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) {}
  bool deleteData :1;
  bool ifExists :1;
  bool ignoreProtection :1;
  bool environmentContext :1;
  bool needResult :1;
  bool catName :1;
} _DropPartitionsRequest__isset;

class DropPartitionsRequest : public virtual ::apache::thrift::TBase {
 public:

  DropPartitionsRequest(const DropPartitionsRequest&);
  DropPartitionsRequest& operator=(const DropPartitionsRequest&);
  DropPartitionsRequest() : dbName(), tblName(), deleteData(0), ifExists(true), ignoreProtection(0), needResult(true), catName() {
  }

  virtual ~DropPartitionsRequest() noexcept;
  std::string dbName;
  std::string tblName;
  RequestPartsSpec parts;
  bool deleteData;
  bool ifExists;
  bool ignoreProtection;
  EnvironmentContext environmentContext;
  bool needResult;
  std::string catName;

  _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);

  bool 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;
    return true;
  }
  bool operator != (const DropPartitionsRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const DropPartitionsRequest & ) 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;
};

void swap(DropPartitionsRequest &a, DropPartitionsRequest &b);

std::ostream& operator<<(std::ostream& out, const DropPartitionsRequest& 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() : dbName(), tblName(), applyDistinct(true), filter(), ascending(true), maxParts(-1LL), catName(), validWriteIdList() {
  }

  virtual ~PartitionValuesRequest() noexcept;
  std::string dbName;
  std::string tblName;
  std::vector<FieldSchema>  partitionKeys;
  bool applyDistinct;
  std::string filter;
  std::vector<FieldSchema>  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<FieldSchema> & val);

  void __set_applyDistinct(const bool val);

  void __set_filter(const std::string& val);

  void __set_partitionOrder(const std::vector<FieldSchema> & 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
  {
    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;
  }
  bool operator != (const PartitionValuesRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const PartitionValuesRequest & ) 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;
};

void swap(PartitionValuesRequest &a, PartitionValuesRequest &b);

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() {
  }

  virtual ~PartitionValuesRow() noexcept;
  std::vector<std::string>  row;

  void __set_row(const std::vector<std::string> & val);

  bool operator == (const PartitionValuesRow & rhs) const
  {
    if (!(row == rhs.row))
      return false;
    return true;
  }
  bool operator != (const PartitionValuesRow &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const PartitionValuesRow & ) 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;
};

void swap(PartitionValuesRow &a, PartitionValuesRow &b);

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() {
  }

  virtual ~PartitionValuesResponse() noexcept;
  std::vector<PartitionValuesRow>  partitionValues;

  void __set_partitionValues(const std::vector<PartitionValuesRow> & val);

  bool operator == (const PartitionValuesResponse & rhs) const
  {
    if (!(partitionValues == rhs.partitionValues))
      return false;
    return true;
  }
  bool operator != (const PartitionValuesResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const PartitionValuesResponse & ) 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;
};

void swap(PartitionValuesResponse &a, PartitionValuesResponse &b);

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(false), validWriteIdList(false) {}
  bool names :1;
  bool get_col_stats :1;
  bool processorCapabilities :1;
  bool processorIdentifier :1;
  bool engine :1;
  bool validWriteIdList :1;
} _GetPartitionsByNamesRequest__isset;

class GetPartitionsByNamesRequest : public virtual ::apache::thrift::TBase {
 public:

  GetPartitionsByNamesRequest(const GetPartitionsByNamesRequest&);
  GetPartitionsByNamesRequest& operator=(const GetPartitionsByNamesRequest&);
  GetPartitionsByNamesRequest() : db_name(), tbl_name(), get_col_stats(0), processorIdentifier(), engine(), validWriteIdList() {
  }

  virtual ~GetPartitionsByNamesRequest() noexcept;
  std::string db_name;
  std::string tbl_name;
  std::vector<std::string>  names;
  bool get_col_stats;
  std::vector<std::string>  processorCapabilities;
  std::string processorIdentifier;
  std::string engine;
  std::string validWriteIdList;

  _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<std::string> & val);

  void __set_get_col_stats(const bool val);

  void __set_processorCapabilities(const std::vector<std::string> & val);

  void __set_processorIdentifier(const std::string& val);

  void __set_engine(const std::string& val);

  void __set_validWriteIdList(const std::string& val);

  bool 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;
    return true;
  }
  bool operator != (const GetPartitionsByNamesRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetPartitionsByNamesRequest & ) 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;
};

void swap(GetPartitionsByNamesRequest &a, GetPartitionsByNamesRequest &b);

std::ostream& operator<<(std::ostream& out, const GetPartitionsByNamesRequest& obj);


class GetPartitionsByNamesResult : public virtual ::apache::thrift::TBase {
 public:

  GetPartitionsByNamesResult(const GetPartitionsByNamesResult&);
  GetPartitionsByNamesResult& operator=(const GetPartitionsByNamesResult&);
  GetPartitionsByNamesResult() {
  }

  virtual ~GetPartitionsByNamesResult() noexcept;
  std::vector<Partition>  partitions;

  void __set_partitions(const std::vector<Partition> & val);

  bool operator == (const GetPartitionsByNamesResult & rhs) const
  {
    if (!(partitions == rhs.partitions))
      return false;
    return true;
  }
  bool operator != (const GetPartitionsByNamesResult &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetPartitionsByNamesResult & ) 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;
};

void swap(GetPartitionsByNamesResult &a, GetPartitionsByNamesResult &b);

std::ostream& operator<<(std::ostream& out, const GetPartitionsByNamesResult& 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() : resourceType((ResourceType::type)0), uri() {
  }

  virtual ~ResourceUri() noexcept;
  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
  {
    if (!(resourceType == rhs.resourceType))
      return false;
    if (!(uri == rhs.uri))
      return false;
    return true;
  }
  bool operator != (const ResourceUri &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ResourceUri & ) 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;
};

void swap(ResourceUri &a, ResourceUri &b);

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() : functionName(), dbName(), className(), ownerName(), ownerType((PrincipalType::type)0), createTime(0), functionType((FunctionType::type)0), catName() {
  }

  virtual ~Function() noexcept;
  std::string functionName;
  std::string dbName;
  std::string className;
  std::string ownerName;
  PrincipalType::type ownerType;
  int32_t createTime;
  FunctionType::type functionType;
  std::vector<ResourceUri>  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<ResourceUri> & val);

  void __set_catName(const std::string& val);

  bool 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;
  }
  bool operator != (const Function &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Function & ) 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;
};

void swap(Function &a, Function &b);

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() : id(0), state((TxnState::type)0), user(), hostname(), agentInfo("Unknown"), heartbeatCount(0), metaInfo(), startedTime(0), lastHeartbeatTime(0) {
  }

  virtual ~TxnInfo() noexcept;
  int64_t id;
  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
  {
    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;
  }
  bool operator != (const TxnInfo &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TxnInfo & ) 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;
};

void swap(TxnInfo &a, TxnInfo &b);

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() : txn_high_water_mark(0) {
  }

  virtual ~GetOpenTxnsInfoResponse() noexcept;
  int64_t txn_high_water_mark;
  std::vector<TxnInfo>  open_txns;

  void __set_txn_high_water_mark(const int64_t val);

  void __set_open_txns(const std::vector<TxnInfo> & val);

  bool 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;
  }
  bool operator != (const GetOpenTxnsInfoResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetOpenTxnsInfoResponse & ) 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;
};

void swap(GetOpenTxnsInfoResponse &a, GetOpenTxnsInfoResponse &b);

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() : txn_high_water_mark(0), min_open_txn(0), abortedBits() {
  }

  virtual ~GetOpenTxnsResponse() noexcept;
  int64_t txn_high_water_mark;
  std::vector<int64_t>  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<int64_t> & val);

  void __set_min_open_txn(const int64_t val);

  void __set_abortedBits(const std::string& val);

  bool 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;
  }
  bool operator != (const GetOpenTxnsResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetOpenTxnsResponse & ) 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;
};

void swap(GetOpenTxnsResponse &a, GetOpenTxnsResponse &b);

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() : num_txns(0), user(), hostname(), agentInfo("Unknown"), replPolicy(), txn_type((TxnType::type)0) {
    txn_type = (TxnType::type)0;

  }

  virtual ~OpenTxnRequest() noexcept;
  int32_t num_txns;
  std::string user;
  std::string hostname;
  std::string agentInfo;
  std::string replPolicy;
  std::vector<int64_t>  replSrcTxnIds;
  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<int64_t> & val);

  void __set_txn_type(const TxnType::type val);

  bool 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;
  }
  bool operator != (const OpenTxnRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const OpenTxnRequest & ) 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;
};

void swap(OpenTxnRequest &a, OpenTxnRequest &b);

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() {
  }

  virtual ~OpenTxnsResponse() noexcept;
  std::vector<int64_t>  txn_ids;

  void __set_txn_ids(const std::vector<int64_t> & val);

  bool operator == (const OpenTxnsResponse & rhs) const
  {
    if (!(txn_ids == rhs.txn_ids))
      return false;
    return true;
  }
  bool operator != (const OpenTxnsResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const OpenTxnsResponse & ) 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;
};

void swap(OpenTxnsResponse &a, OpenTxnsResponse &b);

std::ostream& operator<<(std::ostream& out, const OpenTxnsResponse& obj);

typedef struct _AbortTxnRequest__isset {
  _AbortTxnRequest__isset() : replPolicy(false) {}
  bool replPolicy :1;
} _AbortTxnRequest__isset;

class AbortTxnRequest : public virtual ::apache::thrift::TBase {
 public:

  AbortTxnRequest(const AbortTxnRequest&);
  AbortTxnRequest& operator=(const AbortTxnRequest&);
  AbortTxnRequest() : txnid(0), replPolicy() {
  }

  virtual ~AbortTxnRequest() noexcept;
  int64_t txnid;
  std::string replPolicy;

  _AbortTxnRequest__isset __isset;

  void __set_txnid(const int64_t val);

  void __set_replPolicy(const std::string& val);

  bool 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;
    return true;
  }
  bool operator != (const AbortTxnRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const AbortTxnRequest & ) 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;
};

void swap(AbortTxnRequest &a, AbortTxnRequest &b);

std::ostream& operator<<(std::ostream& out, const AbortTxnRequest& obj);


class AbortTxnsRequest : public virtual ::apache::thrift::TBase {
 public:

  AbortTxnsRequest(const AbortTxnsRequest&);
  AbortTxnsRequest& operator=(const AbortTxnsRequest&);
  AbortTxnsRequest() {
  }

  virtual ~AbortTxnsRequest() noexcept;
  std::vector<int64_t>  txn_ids;

  void __set_txn_ids(const std::vector<int64_t> & val);

  bool operator == (const AbortTxnsRequest & rhs) const
  {
    if (!(txn_ids == rhs.txn_ids))
      return false;
    return true;
  }
  bool operator != (const AbortTxnsRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const AbortTxnsRequest & ) 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;
};

void swap(AbortTxnsRequest &a, AbortTxnsRequest &b);

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() : tableId(0), key(), value() {
  }

  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
  {
    if (!(tableId == rhs.tableId))
      return false;
    if (!(key == rhs.key))
      return false;
    if (!(value == rhs.value))
      return false;
    return true;
  }
  bool operator != (const CommitTxnKeyValue &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const CommitTxnKeyValue & ) 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;
};

void swap(CommitTxnKeyValue &a, CommitTxnKeyValue &b);

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() : writeId(0), database(), table(), files(), partition(), tableObj(), partitionObj() {
  }

  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
  {
    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;
  }
  bool operator != (const WriteEventInfo &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WriteEventInfo & ) 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;
};

void swap(WriteEventInfo &a, WriteEventInfo &b);

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() : database(), lastReplId(0), table(), catalog() {
  }

  virtual ~ReplLastIdInfo() noexcept;
  std::string database;
  int64_t lastReplId;
  std::string table;
  std::string catalog;
  std::vector<std::string>  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<std::string> & val);

  bool 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;
  }
  bool operator != (const ReplLastIdInfo &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ReplLastIdInfo & ) 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;
};

void swap(ReplLastIdInfo &a, ReplLastIdInfo &b);

std::ostream& operator<<(std::ostream& out, const ReplLastIdInfo& obj);

typedef struct _CommitTxnRequest__isset {
  _CommitTxnRequest__isset() : replPolicy(false), writeEventInfos(false), replLastIdInfo(false), keyValue(false), exclWriteEnabled(true) {}
  bool replPolicy :1;
  bool writeEventInfos :1;
  bool replLastIdInfo :1;
  bool keyValue :1;
  bool exclWriteEnabled :1;
} _CommitTxnRequest__isset;

class CommitTxnRequest : public virtual ::apache::thrift::TBase {
 public:

  CommitTxnRequest(const CommitTxnRequest&);
  CommitTxnRequest& operator=(const CommitTxnRequest&);
  CommitTxnRequest() : txnid(0), replPolicy(), exclWriteEnabled(true) {
  }

  virtual ~CommitTxnRequest() noexcept;
  int64_t txnid;
  std::string replPolicy;
  std::vector<WriteEventInfo>  writeEventInfos;
  ReplLastIdInfo replLastIdInfo;
  CommitTxnKeyValue keyValue;
  bool exclWriteEnabled;

  _CommitTxnRequest__isset __isset;

  void __set_txnid(const int64_t val);

  void __set_replPolicy(const std::string& val);

  void __set_writeEventInfos(const std::vector<WriteEventInfo> & val);

  void __set_replLastIdInfo(const ReplLastIdInfo& val);

  void __set_keyValue(const CommitTxnKeyValue& val);

  void __set_exclWriteEnabled(const bool val);

  bool 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;
    return true;
  }
  bool operator != (const CommitTxnRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const CommitTxnRequest & ) 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;
};

void swap(CommitTxnRequest &a, CommitTxnRequest &b);

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() : validWriteIdlist(), user(), hostName(), dbName(), tableName() {
  }

  virtual ~ReplTblWriteIdStateRequest() noexcept;
  std::string validWriteIdlist;
  std::string user;
  std::string hostName;
  std::string dbName;
  std::string tableName;
  std::vector<std::string>  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<std::string> & val);

  bool 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;
  }
  bool operator != (const ReplTblWriteIdStateRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ReplTblWriteIdStateRequest & ) 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;
};

void swap(ReplTblWriteIdStateRequest &a, ReplTblWriteIdStateRequest &b);

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() : validTxnList(), writeId(0) {
  }

  virtual ~GetValidWriteIdsRequest() noexcept;
  std::vector<std::string>  fullTableNames;
  std::string validTxnList;
  int64_t writeId;

  _GetValidWriteIdsRequest__isset __isset;

  void __set_fullTableNames(const std::vector<std::string> & val);

  void __set_validTxnList(const std::string& val);

  void __set_writeId(const int64_t val);

  bool 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;
  }
  bool operator != (const GetValidWriteIdsRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetValidWriteIdsRequest & ) 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;
};

void swap(GetValidWriteIdsRequest &a, GetValidWriteIdsRequest &b);

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() : fullTableName(), writeIdHighWaterMark(0), minOpenWriteId(0), abortedBits() {
  }

  virtual ~TableValidWriteIds() noexcept;
  std::string fullTableName;
  int64_t writeIdHighWaterMark;
  std::vector<int64_t>  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<int64_t> & val);

  void __set_minOpenWriteId(const int64_t val);

  void __set_abortedBits(const std::string& val);

  bool 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;
  }
  bool operator != (const TableValidWriteIds &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TableValidWriteIds & ) 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;
};

void swap(TableValidWriteIds &a, TableValidWriteIds &b);

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() {
  }

  virtual ~GetValidWriteIdsResponse() noexcept;
  std::vector<TableValidWriteIds>  tblValidWriteIds;

  void __set_tblValidWriteIds(const std::vector<TableValidWriteIds> & val);

  bool operator == (const GetValidWriteIdsResponse & rhs) const
  {
    if (!(tblValidWriteIds == rhs.tblValidWriteIds))
      return false;
    return true;
  }
  bool operator != (const GetValidWriteIdsResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetValidWriteIdsResponse & ) 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;
};

void swap(GetValidWriteIdsResponse &a, GetValidWriteIdsResponse &b);

std::ostream& operator<<(std::ostream& out, const GetValidWriteIdsResponse& obj);


class TxnToWriteId : public virtual ::apache::thrift::TBase {
 public:

  TxnToWriteId(const TxnToWriteId&);
  TxnToWriteId& operator=(const TxnToWriteId&);
  TxnToWriteId() : txnId(0), writeId(0) {
  }

  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
  {
    if (!(txnId == rhs.txnId))
      return false;
    if (!(writeId == rhs.writeId))
      return false;
    return true;
  }
  bool operator != (const TxnToWriteId &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TxnToWriteId & ) 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;
};

void swap(TxnToWriteId &a, TxnToWriteId &b);

std::ostream& operator<<(std::ostream& out, const TxnToWriteId& obj);

typedef struct _AllocateTableWriteIdsRequest__isset {
  _AllocateTableWriteIdsRequest__isset() : txnIds(false), replPolicy(false), srcTxnToWriteIdList(false) {}
  bool txnIds :1;
  bool replPolicy :1;
  bool srcTxnToWriteIdList :1;
} _AllocateTableWriteIdsRequest__isset;

class AllocateTableWriteIdsRequest : public virtual ::apache::thrift::TBase {
 public:

  AllocateTableWriteIdsRequest(const AllocateTableWriteIdsRequest&);
  AllocateTableWriteIdsRequest& operator=(const AllocateTableWriteIdsRequest&);
  AllocateTableWriteIdsRequest() : dbName(), tableName(), replPolicy() {
  }

  virtual ~AllocateTableWriteIdsRequest() noexcept;
  std::string dbName;
  std::string tableName;
  std::vector<int64_t>  txnIds;
  std::string replPolicy;
  std::vector<TxnToWriteId>  srcTxnToWriteIdList;

  _AllocateTableWriteIdsRequest__isset __isset;

  void __set_dbName(const std::string& val);

  void __set_tableName(const std::string& val);

  void __set_txnIds(const std::vector<int64_t> & val);

  void __set_replPolicy(const std::string& val);

  void __set_srcTxnToWriteIdList(const std::vector<TxnToWriteId> & val);

  bool 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;
    return true;
  }
  bool operator != (const AllocateTableWriteIdsRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const AllocateTableWriteIdsRequest & ) 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;
};

void swap(AllocateTableWriteIdsRequest &a, AllocateTableWriteIdsRequest &b);

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() {
  }

  virtual ~AllocateTableWriteIdsResponse() noexcept;
  std::vector<TxnToWriteId>  txnToWriteIds;

  void __set_txnToWriteIds(const std::vector<TxnToWriteId> & val);

  bool operator == (const AllocateTableWriteIdsResponse & rhs) const
  {
    if (!(txnToWriteIds == rhs.txnToWriteIds))
      return false;
    return true;
  }
  bool operator != (const AllocateTableWriteIdsResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const AllocateTableWriteIdsResponse & ) 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;
};

void swap(AllocateTableWriteIdsResponse &a, AllocateTableWriteIdsResponse &b);

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() : dbName(), tableName() {
  }

  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
  {
    if (!(dbName == rhs.dbName))
      return false;
    if (!(tableName == rhs.tableName))
      return false;
    return true;
  }
  bool operator != (const MaxAllocatedTableWriteIdRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const MaxAllocatedTableWriteIdRequest & ) 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;
};

void swap(MaxAllocatedTableWriteIdRequest &a, MaxAllocatedTableWriteIdRequest &b);

std::ostream& operator<<(std::ostream& out, const MaxAllocatedTableWriteIdRequest& obj);


class MaxAllocatedTableWriteIdResponse : public virtual ::apache::thrift::TBase {
 public:

  MaxAllocatedTableWriteIdResponse(const MaxAllocatedTableWriteIdResponse&);
  MaxAllocatedTableWriteIdResponse& operator=(const MaxAllocatedTableWriteIdResponse&);
  MaxAllocatedTableWriteIdResponse() : maxWriteId(0) {
  }

  virtual ~MaxAllocatedTableWriteIdResponse() noexcept;
  int64_t maxWriteId;

  void __set_maxWriteId(const int64_t val);

  bool operator == (const MaxAllocatedTableWriteIdResponse & rhs) const
  {
    if (!(maxWriteId == rhs.maxWriteId))
      return false;
    return true;
  }
  bool operator != (const MaxAllocatedTableWriteIdResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const MaxAllocatedTableWriteIdResponse & ) 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;
};

void swap(MaxAllocatedTableWriteIdResponse &a, MaxAllocatedTableWriteIdResponse &b);

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() : dbName(), tableName(), seedWriteId(0) {
  }

  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
  {
    if (!(dbName == rhs.dbName))
      return false;
    if (!(tableName == rhs.tableName))
      return false;
    if (!(seedWriteId == rhs.seedWriteId))
      return false;
    return true;
  }
  bool operator != (const SeedTableWriteIdsRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const SeedTableWriteIdsRequest & ) 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;
};

void swap(SeedTableWriteIdsRequest &a, SeedTableWriteIdsRequest &b);

std::ostream& operator<<(std::ostream& out, const SeedTableWriteIdsRequest& obj);


class SeedTxnIdRequest : public virtual ::apache::thrift::TBase {
 public:

  SeedTxnIdRequest(const SeedTxnIdRequest&);
  SeedTxnIdRequest& operator=(const SeedTxnIdRequest&);
  SeedTxnIdRequest() : seedTxnId(0) {
  }

  virtual ~SeedTxnIdRequest() noexcept;
  int64_t seedTxnId;

  void __set_seedTxnId(const int64_t val);

  bool operator == (const SeedTxnIdRequest & rhs) const
  {
    if (!(seedTxnId == rhs.seedTxnId))
      return false;
    return true;
  }
  bool operator != (const SeedTxnIdRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const SeedTxnIdRequest & ) 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;
};

void swap(SeedTxnIdRequest &a, SeedTxnIdRequest &b);

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() : type((LockType::type)0), level((LockLevel::type)0), dbname(), tablename(), partitionname(), operationType((DataOperationType::type)5), isTransactional(false), isDynamicPartitionWrite(false) {
    operationType = (DataOperationType::type)5;

  }

  virtual ~LockComponent() noexcept;
  LockType::type type;
  LockLevel::type level;
  std::string dbname;
  std::string tablename;
  std::string partitionname;
  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
  {
    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;
  }
  bool operator != (const LockComponent &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const LockComponent & ) 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;
};

void swap(LockComponent &a, LockComponent &b);

std::ostream& operator<<(std::ostream& out, const LockComponent& obj);

typedef struct _LockRequest__isset {
  _LockRequest__isset() : txnid(false), agentInfo(true), zeroWaitReadEnabled(true) {}
  bool txnid :1;
  bool agentInfo :1;
  bool zeroWaitReadEnabled :1;
} _LockRequest__isset;

class LockRequest : public virtual ::apache::thrift::TBase {
 public:

  LockRequest(const LockRequest&);
  LockRequest& operator=(const LockRequest&);
  LockRequest() : txnid(0), user(), hostname(), agentInfo("Unknown"), zeroWaitReadEnabled(false) {
  }

  virtual ~LockRequest() noexcept;
  std::vector<LockComponent>  component;
  int64_t txnid;
  std::string user;
  std::string hostname;
  std::string agentInfo;
  bool zeroWaitReadEnabled;

  _LockRequest__isset __isset;

  void __set_component(const std::vector<LockComponent> & 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);

  bool 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;
    return true;
  }
  bool operator != (const LockRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const LockRequest & ) 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;
};

void swap(LockRequest &a, LockRequest &b);

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() : lockid(0), state((LockState::type)0), errorMessage() {
  }

  virtual ~LockResponse() noexcept;
  int64_t lockid;
  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
  {
    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;
  }
  bool operator != (const LockResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const LockResponse & ) 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;
};

void swap(LockResponse &a, LockResponse &b);

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&);
  CheckLockRequest& operator=(const CheckLockRequest&);
  CheckLockRequest() : lockid(0), txnid(0), elapsed_ms(0) {
  }

  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
  {
    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;
  }
  bool operator != (const CheckLockRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const CheckLockRequest & ) 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;
};

void swap(CheckLockRequest &a, CheckLockRequest &b);

std::ostream& operator<<(std::ostream& out, const CheckLockRequest& obj);


class UnlockRequest : public virtual ::apache::thrift::TBase {
 public:

  UnlockRequest(const UnlockRequest&);
  UnlockRequest& operator=(const UnlockRequest&);
  UnlockRequest() : lockid(0) {
  }

  virtual ~UnlockRequest() noexcept;
  int64_t lockid;

  void __set_lockid(const int64_t val);

  bool operator == (const UnlockRequest & rhs) const
  {
    if (!(lockid == rhs.lockid))
      return false;
    return true;
  }
  bool operator != (const UnlockRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const UnlockRequest & ) 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;
};

void swap(UnlockRequest &a, UnlockRequest &b);

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() : dbname(), tablename(), partname(), isExtended(false), txnid(0) {
  }

  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
  {
    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;
  }
  bool operator != (const ShowLocksRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ShowLocksRequest & ) 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;
};

void swap(ShowLocksRequest &a, ShowLocksRequest &b);

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() : lockid(0), dbname(), tablename(), partname(), state((LockState::type)0), type((LockType::type)0), txnid(0), lastheartbeat(0), acquiredat(0), user(), hostname(), heartbeatCount(0), agentInfo(), blockedByExtId(0), blockedByIntId(0), lockIdInternal(0) {
  }

  virtual ~ShowLocksResponseElement() noexcept;
  int64_t lockid;
  std::string dbname;
  std::string tablename;
  std::string partname;
  LockState::type state;
  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
  {
    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;
  }
  bool operator != (const ShowLocksResponseElement &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ShowLocksResponseElement & ) 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;
};

void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b);

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() {
  }

  virtual ~ShowLocksResponse() noexcept;
  std::vector<ShowLocksResponseElement>  locks;

  _ShowLocksResponse__isset __isset;

  void __set_locks(const std::vector<ShowLocksResponseElement> & val);

  bool operator == (const ShowLocksResponse & rhs) const
  {
    if (!(locks == rhs.locks))
      return false;
    return true;
  }
  bool operator != (const ShowLocksResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ShowLocksResponse & ) 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;
};

void swap(ShowLocksResponse &a, ShowLocksResponse &b);

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&);
  HeartbeatRequest& operator=(const HeartbeatRequest&);
  HeartbeatRequest() : lockid(0), txnid(0) {
  }

  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
  {
    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;
  }
  bool operator != (const HeartbeatRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const HeartbeatRequest & ) 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;
};

void swap(HeartbeatRequest &a, HeartbeatRequest &b);

std::ostream& operator<<(std::ostream& out, const HeartbeatRequest& obj);


class HeartbeatTxnRangeRequest : public virtual ::apache::thrift::TBase {
 public:

  HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest&);
  HeartbeatTxnRangeRequest& operator=(const HeartbeatTxnRangeRequest&);
  HeartbeatTxnRangeRequest() : min(0), max(0) {
  }

  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
  {
    if (!(min == rhs.min))
      return false;
    if (!(max == rhs.max))
      return false;
    return true;
  }
  bool operator != (const HeartbeatTxnRangeRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const HeartbeatTxnRangeRequest & ) 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;
};

void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b);

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() {
  }

  virtual ~HeartbeatTxnRangeResponse() noexcept;
  std::set<int64_t>  aborted;
  std::set<int64_t>  nosuch;

  void __set_aborted(const std::set<int64_t> & val);

  void __set_nosuch(const std::set<int64_t> & val);

  bool operator == (const HeartbeatTxnRangeResponse & rhs) const
  {
    if (!(aborted == rhs.aborted))
      return false;
    if (!(nosuch == rhs.nosuch))
      return false;
    return true;
  }
  bool operator != (const HeartbeatTxnRangeResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const HeartbeatTxnRangeResponse & ) 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;
};

void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b);

std::ostream& operator<<(std::ostream& out, const HeartbeatTxnRangeResponse& obj);

typedef struct _CompactionRequest__isset {
  _CompactionRequest__isset() : partitionname(false), runas(false), properties(false) {}
  bool partitionname :1;
  bool runas :1;
  bool properties :1;
} _CompactionRequest__isset;

class CompactionRequest : public virtual ::apache::thrift::TBase {
 public:

  CompactionRequest(const CompactionRequest&);
  CompactionRequest& operator=(const CompactionRequest&);
  CompactionRequest() : dbname(), tablename(), partitionname(), type((CompactionType::type)0), runas() {
  }

  virtual ~CompactionRequest() noexcept;
  std::string dbname;
  std::string tablename;
  std::string partitionname;
  CompactionType::type type;
  std::string runas;
  std::map<std::string, std::string>  properties;

  _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<std::string, std::string> & val);

  bool 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;
    return true;
  }
  bool operator != (const CompactionRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const CompactionRequest & ) 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;
};

void swap(CompactionRequest &a, CompactionRequest &b);

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) {}
  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;
} _CompactionInfoStruct__isset;

class CompactionInfoStruct : public virtual ::apache::thrift::TBase {
 public:

  CompactionInfoStruct(const CompactionInfoStruct&);
  CompactionInfoStruct& operator=(const CompactionInfoStruct&);
  CompactionInfoStruct() : id(0), dbname(), tablename(), partitionname(), type((CompactionType::type)0), runas(), properties(), toomanyaborts(0), state(), workerId(), start(0), highestWriteId(0), errorMessage(), hasoldabort(0), enqueueTime(0) {
  }

  virtual ~CompactionInfoStruct() noexcept;
  int64_t id;
  std::string dbname;
  std::string tablename;
  std::string partitionname;
  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;

  _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);

  bool 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;
    return true;
  }
  bool operator != (const CompactionInfoStruct &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const CompactionInfoStruct & ) 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;
};

void swap(CompactionInfoStruct &a, CompactionInfoStruct &b);

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() {
  }

  virtual ~OptionalCompactionInfoStruct() noexcept;
  CompactionInfoStruct ci;

  _OptionalCompactionInfoStruct__isset __isset;

  void __set_ci(const CompactionInfoStruct& val);

  bool operator == (const OptionalCompactionInfoStruct & rhs) const
  {
    if (__isset.ci != rhs.__isset.ci)
      return false;
    else if (__isset.ci && !(ci == rhs.ci))
      return false;
    return true;
  }
  bool operator != (const OptionalCompactionInfoStruct &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const OptionalCompactionInfoStruct & ) 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;
};

void swap(OptionalCompactionInfoStruct &a, OptionalCompactionInfoStruct &b);

std::ostream& operator<<(std::ostream& out, const OptionalCompactionInfoStruct& obj);


class CompactionResponse : public virtual ::apache::thrift::TBase {
 public:

  CompactionResponse(const CompactionResponse&);
  CompactionResponse& operator=(const CompactionResponse&);
  CompactionResponse() : id(0), state(), accepted(0) {
  }

  virtual ~CompactionResponse() noexcept;
  int64_t id;
  std::string state;
  bool accepted;

  void __set_id(const int64_t val);

  void __set_state(const std::string& val);

  void __set_accepted(const bool val);

  bool operator == (const CompactionResponse & rhs) const
  {
    if (!(id == rhs.id))
      return false;
    if (!(state == rhs.state))
      return false;
    if (!(accepted == rhs.accepted))
      return false;
    return true;
  }
  bool operator != (const CompactionResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const CompactionResponse & ) 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;
};

void swap(CompactionResponse &a, CompactionResponse &b);

std::ostream& operator<<(std::ostream& out, const CompactionResponse& obj);


class ShowCompactRequest : public virtual ::apache::thrift::TBase {
 public:

  ShowCompactRequest(const ShowCompactRequest&);
  ShowCompactRequest& operator=(const ShowCompactRequest&);
  ShowCompactRequest() {
  }

  virtual ~ShowCompactRequest() noexcept;

  bool operator == (const ShowCompactRequest & /* rhs */) const
  {
    return true;
  }
  bool operator != (const ShowCompactRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ShowCompactRequest & ) 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;
};

void swap(ShowCompactRequest &a, ShowCompactRequest &b);

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) {}
  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;
} _ShowCompactResponseElement__isset;

class ShowCompactResponseElement : public virtual ::apache::thrift::TBase {
 public:

  ShowCompactResponseElement(const ShowCompactResponseElement&);
  ShowCompactResponseElement& operator=(const ShowCompactResponseElement&);
  ShowCompactResponseElement() : dbname(), tablename(), partitionname(), type((CompactionType::type)0), state(), workerid(), start(0), runAs(), hightestTxnId(0), metaInfo(), endTime(0), hadoopJobId("None"), id(0), errorMessage(), enqueueTime(0) {
  }

  virtual ~ShowCompactResponseElement() noexcept;
  std::string dbname;
  std::string tablename;
  std::string partitionname;
  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;

  _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);

  bool 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;
    return true;
  }
  bool operator != (const ShowCompactResponseElement &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ShowCompactResponseElement & ) 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;
};

void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b);

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() {
  }

  virtual ~ShowCompactResponse() noexcept;
  std::vector<ShowCompactResponseElement>  compacts;

  void __set_compacts(const std::vector<ShowCompactResponseElement> & val);

  bool operator == (const ShowCompactResponse & rhs) const
  {
    if (!(compacts == rhs.compacts))
      return false;
    return true;
  }
  bool operator != (const ShowCompactResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ShowCompactResponse & ) 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;
};

void swap(ShowCompactResponse &a, ShowCompactResponse &b);

std::ostream& operator<<(std::ostream& out, const ShowCompactResponse& 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() : txnid(0), writeid(0), dbname(), tablename(), operationType((DataOperationType::type)5) {
    operationType = (DataOperationType::type)5;

  }

  virtual ~AddDynamicPartitions() noexcept;
  int64_t txnid;
  int64_t writeid;
  std::string dbname;
  std::string tablename;
  std::vector<std::string>  partitionnames;
  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<std::string> & val);

  void __set_operationType(const DataOperationType::type val);

  bool 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;
  }
  bool operator != (const AddDynamicPartitions &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const AddDynamicPartitions & ) 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;
};

void swap(AddDynamicPartitions &a, AddDynamicPartitions &b);

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() : isnull(0), time(0), txnid(0), dbname(), tablename(), partitionname() {
  }

  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
  {
    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;
  }
  bool operator != (const BasicTxnInfo &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const BasicTxnInfo & ) 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;
};

void swap(BasicTxnInfo &a, BasicTxnInfo &b);

std::ostream& operator<<(std::ostream& out, const BasicTxnInfo& obj);

typedef struct _NotificationEventRequest__isset {
  _NotificationEventRequest__isset() : maxEvents(false), eventTypeSkipList(false) {}
  bool maxEvents :1;
  bool eventTypeSkipList :1;
} _NotificationEventRequest__isset;

class NotificationEventRequest : public virtual ::apache::thrift::TBase {
 public:

  NotificationEventRequest(const NotificationEventRequest&);
  NotificationEventRequest& operator=(const NotificationEventRequest&);
  NotificationEventRequest() : lastEvent(0), maxEvents(0) {
  }

  virtual ~NotificationEventRequest() noexcept;
  int64_t lastEvent;
  int32_t maxEvents;
  std::vector<std::string>  eventTypeSkipList;

  _NotificationEventRequest__isset __isset;

  void __set_lastEvent(const int64_t val);

  void __set_maxEvents(const int32_t val);

  void __set_eventTypeSkipList(const std::vector<std::string> & val);

  bool 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;
    return true;
  }
  bool operator != (const NotificationEventRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const NotificationEventRequest & ) 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;
};

void swap(NotificationEventRequest &a, NotificationEventRequest &b);

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() : eventId(0), eventTime(0), eventType(), dbName(), tableName(), message(), messageFormat(), catName() {
  }

  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
  {
    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;
  }
  bool operator != (const NotificationEvent &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const NotificationEvent & ) 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;
};

void swap(NotificationEvent &a, NotificationEvent &b);

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() {
  }

  virtual ~NotificationEventResponse() noexcept;
  std::vector<NotificationEvent>  events;

  void __set_events(const std::vector<NotificationEvent> & val);

  bool operator == (const NotificationEventResponse & rhs) const
  {
    if (!(events == rhs.events))
      return false;
    return true;
  }
  bool operator != (const NotificationEventResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const NotificationEventResponse & ) 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;
};

void swap(NotificationEventResponse &a, NotificationEventResponse &b);

std::ostream& operator<<(std::ostream& out, const NotificationEventResponse& obj);


class CurrentNotificationEventId : public virtual ::apache::thrift::TBase {
 public:

  CurrentNotificationEventId(const CurrentNotificationEventId&);
  CurrentNotificationEventId& operator=(const CurrentNotificationEventId&);
  CurrentNotificationEventId() : eventId(0) {
  }

  virtual ~CurrentNotificationEventId() noexcept;
  int64_t eventId;

  void __set_eventId(const int64_t val);

  bool operator == (const CurrentNotificationEventId & rhs) const
  {
    if (!(eventId == rhs.eventId))
      return false;
    return true;
  }
  bool operator != (const CurrentNotificationEventId &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const CurrentNotificationEventId & ) 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;
};

void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b);

std::ostream& operator<<(std::ostream& out, const CurrentNotificationEventId& obj);

typedef struct _NotificationEventsCountRequest__isset {
  _NotificationEventsCountRequest__isset() : catName(false), toEventId(false), limit(false) {}
  bool catName :1;
  bool toEventId :1;
  bool limit :1;
} _NotificationEventsCountRequest__isset;

class NotificationEventsCountRequest : public virtual ::apache::thrift::TBase {
 public:

  NotificationEventsCountRequest(const NotificationEventsCountRequest&);
  NotificationEventsCountRequest& operator=(const NotificationEventsCountRequest&);
  NotificationEventsCountRequest() : fromEventId(0), dbName(), catName(), toEventId(0), limit(0) {
  }

  virtual ~NotificationEventsCountRequest() noexcept;
  int64_t fromEventId;
  std::string dbName;
  std::string catName;
  int64_t toEventId;
  int64_t limit;

  _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);

  bool 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;
    return true;
  }
  bool operator != (const NotificationEventsCountRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const NotificationEventsCountRequest & ) 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;
};

void swap(NotificationEventsCountRequest &a, NotificationEventsCountRequest &b);

std::ostream& operator<<(std::ostream& out, const NotificationEventsCountRequest& obj);


class NotificationEventsCountResponse : public virtual ::apache::thrift::TBase {
 public:

  NotificationEventsCountResponse(const NotificationEventsCountResponse&);
  NotificationEventsCountResponse& operator=(const NotificationEventsCountResponse&);
  NotificationEventsCountResponse() : eventsCount(0) {
  }

  virtual ~NotificationEventsCountResponse() noexcept;
  int64_t eventsCount;

  void __set_eventsCount(const int64_t val);

  bool operator == (const NotificationEventsCountResponse & rhs) const
  {
    if (!(eventsCount == rhs.eventsCount))
      return false;
    return true;
  }
  bool operator != (const NotificationEventsCountResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const NotificationEventsCountResponse & ) 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;
};

void swap(NotificationEventsCountResponse &a, NotificationEventsCountResponse &b);

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() : replace(0) {
  }

  virtual ~InsertEventRequestData() noexcept;
  bool replace;
  std::vector<std::string>  filesAdded;
  std::vector<std::string>  filesAddedChecksum;
  std::vector<std::string>  subDirectoryList;
  std::vector<std::string>  partitionVal;

  _InsertEventRequestData__isset __isset;

  void __set_replace(const bool val);

  void __set_filesAdded(const std::vector<std::string> & val);

  void __set_filesAddedChecksum(const std::vector<std::string> & val);

  void __set_subDirectoryList(const std::vector<std::string> & val);

  void __set_partitionVal(const std::vector<std::string> & val);

  bool 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;
  }
  bool operator != (const InsertEventRequestData &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const InsertEventRequestData & ) 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;
};

void swap(InsertEventRequestData &a, InsertEventRequestData &b);

std::ostream& operator<<(std::ostream& out, const InsertEventRequestData& obj);

typedef struct _FireEventRequestData__isset {
  _FireEventRequestData__isset() : insertData(false), insertDatas(false) {}
  bool insertData :1;
  bool insertDatas :1;
} _FireEventRequestData__isset;

class FireEventRequestData : public virtual ::apache::thrift::TBase {
 public:

  FireEventRequestData(const FireEventRequestData&);
  FireEventRequestData& operator=(const FireEventRequestData&);
  FireEventRequestData() {
  }

  virtual ~FireEventRequestData() noexcept;
  InsertEventRequestData insertData;
  std::vector<InsertEventRequestData>  insertDatas;

  _FireEventRequestData__isset __isset;

  void __set_insertData(const InsertEventRequestData& val);

  void __set_insertDatas(const std::vector<InsertEventRequestData> & val);

  bool 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;
    return true;
  }
  bool operator != (const FireEventRequestData &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const FireEventRequestData & ) 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;
};

void swap(FireEventRequestData &a, FireEventRequestData &b);

std::ostream& operator<<(std::ostream& out, const FireEventRequestData& obj);

typedef struct _FireEventRequest__isset {
  _FireEventRequest__isset() : dbName(false), tableName(false), partitionVals(false), catName(false) {}
  bool dbName :1;
  bool tableName :1;
  bool partitionVals :1;
  bool catName :1;
} _FireEventRequest__isset;

class FireEventRequest : public virtual ::apache::thrift::TBase {
 public:

  FireEventRequest(const FireEventRequest&);
  FireEventRequest& operator=(const FireEventRequest&);
  FireEventRequest() : successful(0), dbName(), tableName(), catName() {
  }

  virtual ~FireEventRequest() noexcept;
  bool successful;
  FireEventRequestData data;
  std::string dbName;
  std::string tableName;
  std::vector<std::string>  partitionVals;
  std::string catName;

  _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<std::string> & val);

  void __set_catName(const std::string& val);

  bool 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;
    return true;
  }
  bool operator != (const FireEventRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const FireEventRequest & ) 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;
};

void swap(FireEventRequest &a, FireEventRequest &b);

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() {
  }

  virtual ~FireEventResponse() noexcept;
  std::vector<int64_t>  eventIds;

  _FireEventResponse__isset __isset;

  void __set_eventIds(const std::vector<int64_t> & val);

  bool operator == (const FireEventResponse & rhs) const
  {
    if (!(eventIds == rhs.eventIds))
      return false;
    return true;
  }
  bool operator != (const FireEventResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const FireEventResponse & ) 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;
};

void swap(FireEventResponse &a, FireEventResponse &b);

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() : txnId(0), writeId(0), db(), table() {
  }

  virtual ~WriteNotificationLogRequest() noexcept;
  int64_t txnId;
  int64_t writeId;
  std::string db;
  std::string table;
  InsertEventRequestData fileInfo;
  std::vector<std::string>  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<std::string> & val);

  bool 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;
  }
  bool operator != (const WriteNotificationLogRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WriteNotificationLogRequest & ) 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;
};

void swap(WriteNotificationLogRequest &a, WriteNotificationLogRequest &b);

std::ostream& operator<<(std::ostream& out, const WriteNotificationLogRequest& obj);


class WriteNotificationLogResponse : public virtual ::apache::thrift::TBase {
 public:

  WriteNotificationLogResponse(const WriteNotificationLogResponse&);
  WriteNotificationLogResponse& operator=(const WriteNotificationLogResponse&);
  WriteNotificationLogResponse() {
  }

  virtual ~WriteNotificationLogResponse() noexcept;

  bool operator == (const WriteNotificationLogResponse & /* rhs */) const
  {
    return true;
  }
  bool operator != (const WriteNotificationLogResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WriteNotificationLogResponse & ) 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;
};

void swap(WriteNotificationLogResponse &a, WriteNotificationLogResponse &b);

std::ostream& operator<<(std::ostream& out, const WriteNotificationLogResponse& 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() : metadata(), includeBitset() {
  }

  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
  {
    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;
  }
  bool operator != (const MetadataPpdResult &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const MetadataPpdResult & ) 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;
};

void swap(MetadataPpdResult &a, MetadataPpdResult &b);

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() : isSupported(0) {
  }

  virtual ~GetFileMetadataByExprResult() noexcept;
  std::map<int64_t, MetadataPpdResult>  metadata;
  bool isSupported;

  void __set_metadata(const std::map<int64_t, MetadataPpdResult> & val);

  void __set_isSupported(const bool val);

  bool operator == (const GetFileMetadataByExprResult & rhs) const
  {
    if (!(metadata == rhs.metadata))
      return false;
    if (!(isSupported == rhs.isSupported))
      return false;
    return true;
  }
  bool operator != (const GetFileMetadataByExprResult &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetFileMetadataByExprResult & ) 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;
};

void swap(GetFileMetadataByExprResult &a, GetFileMetadataByExprResult &b);

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() : expr(), doGetFooters(0), type((FileMetadataExprType::type)0) {
  }

  virtual ~GetFileMetadataByExprRequest() noexcept;
  std::vector<int64_t>  fileIds;
  std::string expr;
  bool doGetFooters;
  FileMetadataExprType::type type;

  _GetFileMetadataByExprRequest__isset __isset;

  void __set_fileIds(const std::vector<int64_t> & 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
  {
    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;
  }
  bool operator != (const GetFileMetadataByExprRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetFileMetadataByExprRequest & ) 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;
};

void swap(GetFileMetadataByExprRequest &a, GetFileMetadataByExprRequest &b);

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() : isSupported(0) {
  }

  virtual ~GetFileMetadataResult() noexcept;
  std::map<int64_t, std::string>  metadata;
  bool isSupported;

  void __set_metadata(const std::map<int64_t, std::string> & val);

  void __set_isSupported(const bool val);

  bool operator == (const GetFileMetadataResult & rhs) const
  {
    if (!(metadata == rhs.metadata))
      return false;
    if (!(isSupported == rhs.isSupported))
      return false;
    return true;
  }
  bool operator != (const GetFileMetadataResult &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetFileMetadataResult & ) 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;
};

void swap(GetFileMetadataResult &a, GetFileMetadataResult &b);

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() {
  }

  virtual ~GetFileMetadataRequest() noexcept;
  std::vector<int64_t>  fileIds;

  void __set_fileIds(const std::vector<int64_t> & val);

  bool operator == (const GetFileMetadataRequest & rhs) const
  {
    if (!(fileIds == rhs.fileIds))
      return false;
    return true;
  }
  bool operator != (const GetFileMetadataRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetFileMetadataRequest & ) 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;
};

void swap(GetFileMetadataRequest &a, GetFileMetadataRequest &b);

std::ostream& operator<<(std::ostream& out, const GetFileMetadataRequest& obj);


class PutFileMetadataResult : public virtual ::apache::thrift::TBase {
 public:

  PutFileMetadataResult(const PutFileMetadataResult&);
  PutFileMetadataResult& operator=(const PutFileMetadataResult&);
  PutFileMetadataResult() {
  }

  virtual ~PutFileMetadataResult() noexcept;

  bool operator == (const PutFileMetadataResult & /* rhs */) const
  {
    return true;
  }
  bool operator != (const PutFileMetadataResult &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const PutFileMetadataResult & ) 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;
};

void swap(PutFileMetadataResult &a, PutFileMetadataResult &b);

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() : type((FileMetadataExprType::type)0) {
  }

  virtual ~PutFileMetadataRequest() noexcept;
  std::vector<int64_t>  fileIds;
  std::vector<std::string>  metadata;
  FileMetadataExprType::type type;

  _PutFileMetadataRequest__isset __isset;

  void __set_fileIds(const std::vector<int64_t> & val);

  void __set_metadata(const std::vector<std::string> & val);

  void __set_type(const FileMetadataExprType::type val);

  bool 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;
  }
  bool operator != (const PutFileMetadataRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const PutFileMetadataRequest & ) 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;
};

void swap(PutFileMetadataRequest &a, PutFileMetadataRequest &b);

std::ostream& operator<<(std::ostream& out, const PutFileMetadataRequest& obj);


class ClearFileMetadataResult : public virtual ::apache::thrift::TBase {
 public:

  ClearFileMetadataResult(const ClearFileMetadataResult&);
  ClearFileMetadataResult& operator=(const ClearFileMetadataResult&);
  ClearFileMetadataResult() {
  }

  virtual ~ClearFileMetadataResult() noexcept;

  bool operator == (const ClearFileMetadataResult & /* rhs */) const
  {
    return true;
  }
  bool operator != (const ClearFileMetadataResult &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ClearFileMetadataResult & ) 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;
};

void swap(ClearFileMetadataResult &a, ClearFileMetadataResult &b);

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() {
  }

  virtual ~ClearFileMetadataRequest() noexcept;
  std::vector<int64_t>  fileIds;

  void __set_fileIds(const std::vector<int64_t> & val);

  bool operator == (const ClearFileMetadataRequest & rhs) const
  {
    if (!(fileIds == rhs.fileIds))
      return false;
    return true;
  }
  bool operator != (const ClearFileMetadataRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ClearFileMetadataRequest & ) 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;
};

void swap(ClearFileMetadataRequest &a, ClearFileMetadataRequest &b);

std::ostream& operator<<(std::ostream& out, const ClearFileMetadataRequest& obj);


class CacheFileMetadataResult : public virtual ::apache::thrift::TBase {
 public:

  CacheFileMetadataResult(const CacheFileMetadataResult&);
  CacheFileMetadataResult& operator=(const CacheFileMetadataResult&);
  CacheFileMetadataResult() : isSupported(0) {
  }

  virtual ~CacheFileMetadataResult() noexcept;
  bool isSupported;

  void __set_isSupported(const bool val);

  bool operator == (const CacheFileMetadataResult & rhs) const
  {
    if (!(isSupported == rhs.isSupported))
      return false;
    return true;
  }
  bool operator != (const CacheFileMetadataResult &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const CacheFileMetadataResult & ) 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;
};

void swap(CacheFileMetadataResult &a, CacheFileMetadataResult &b);

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() : dbName(), tblName(), partName(), isAllParts(0) {
  }

  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
  {
    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;
  }
  bool operator != (const CacheFileMetadataRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const CacheFileMetadataRequest & ) 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;
};

void swap(CacheFileMetadataRequest &a, CacheFileMetadataRequest &b);

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() {
  }

  virtual ~GetAllFunctionsResponse() noexcept;
  std::vector<Function>  functions;

  _GetAllFunctionsResponse__isset __isset;

  void __set_functions(const std::vector<Function> & val);

  bool operator == (const GetAllFunctionsResponse & rhs) const
  {
    if (__isset.functions != rhs.__isset.functions)
      return false;
    else if (__isset.functions && !(functions == rhs.functions))
      return false;
    return true;
  }
  bool operator != (const GetAllFunctionsResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetAllFunctionsResponse & ) 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;
};

void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b);

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() {
  }

  virtual ~ClientCapabilities() noexcept;
  std::vector<ClientCapability::type>  values;

  void __set_values(const std::vector<ClientCapability::type> & val);

  bool operator == (const ClientCapabilities & rhs) const
  {
    if (!(values == rhs.values))
      return false;
    return true;
  }
  bool operator != (const ClientCapabilities &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ClientCapabilities & ) 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;
};

void swap(ClientCapabilities &a, ClientCapabilities &b);

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() : includeParamKeyPattern(), excludeParamKeyPattern() {
  }

  virtual ~GetProjectionsSpec() noexcept;
  std::vector<std::string>  fieldList;
  std::string includeParamKeyPattern;
  std::string excludeParamKeyPattern;

  _GetProjectionsSpec__isset __isset;

  void __set_fieldList(const std::vector<std::string> & val);

  void __set_includeParamKeyPattern(const std::string& val);

  void __set_excludeParamKeyPattern(const std::string& val);

  bool 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;
  }
  bool operator != (const GetProjectionsSpec &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetProjectionsSpec & ) 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;
};

void swap(GetProjectionsSpec &a, GetProjectionsSpec &b);

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(false), 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() : dbName(), tblName(), catName(), validWriteIdList(), getColumnStats(0), processorIdentifier(), engine(), id(-1LL) {
  }

  virtual ~GetTableRequest() noexcept;
  std::string dbName;
  std::string tblName;
  ClientCapabilities capabilities;
  std::string catName;
  std::string validWriteIdList;
  bool getColumnStats;
  std::vector<std::string>  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<std::string> & 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
  {
    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;
  }
  bool operator != (const GetTableRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetTableRequest & ) 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;
};

void swap(GetTableRequest &a, GetTableRequest &b);

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() : isStatsCompliant(0) {
  }

  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
  {
    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;
  }
  bool operator != (const GetTableResult &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetTableResult & ) 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;
};

void swap(GetTableResult &a, GetTableResult &b);

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) {}
  bool tblNames :1;
  bool capabilities :1;
  bool catName :1;
  bool processorCapabilities :1;
  bool processorIdentifier :1;
  bool projectionSpec :1;
} _GetTablesRequest__isset;

class GetTablesRequest : public virtual ::apache::thrift::TBase {
 public:

  GetTablesRequest(const GetTablesRequest&);
  GetTablesRequest& operator=(const GetTablesRequest&);
  GetTablesRequest() : dbName(), catName(), processorIdentifier() {
  }

  virtual ~GetTablesRequest() noexcept;
  std::string dbName;
  std::vector<std::string>  tblNames;
  ClientCapabilities capabilities;
  std::string catName;
  std::vector<std::string>  processorCapabilities;
  std::string processorIdentifier;
  GetProjectionsSpec projectionSpec;

  _GetTablesRequest__isset __isset;

  void __set_dbName(const std::string& val);

  void __set_tblNames(const std::vector<std::string> & val);

  void __set_capabilities(const ClientCapabilities& val);

  void __set_catName(const std::string& val);

  void __set_processorCapabilities(const std::vector<std::string> & val);

  void __set_processorIdentifier(const std::string& val);

  void __set_projectionSpec(const GetProjectionsSpec& val);

  bool 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;
    return true;
  }
  bool operator != (const GetTablesRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetTablesRequest & ) 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;
};

void swap(GetTablesRequest &a, GetTablesRequest &b);

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() {
  }

  virtual ~GetTablesResult() noexcept;
  std::vector<Table>  tables;

  void __set_tables(const std::vector<Table> & val);

  bool operator == (const GetTablesResult & rhs) const
  {
    if (!(tables == rhs.tables))
      return false;
    return true;
  }
  bool operator != (const GetTablesResult &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetTablesResult & ) 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;
};

void swap(GetTablesResult &a, GetTablesResult &b);

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() : catalog(), database(), tableNamePattern(), requestedFields(0), limit(0), processorIdentifier() {
  }

  virtual ~GetTablesExtRequest() noexcept;
  std::string catalog;
  std::string database;
  std::string tableNamePattern;
  int32_t requestedFields;
  int32_t limit;
  std::vector<std::string>  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<std::string> & val);

  void __set_processorIdentifier(const std::string& val);

  bool 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;
  }
  bool operator != (const GetTablesExtRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetTablesExtRequest & ) 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;
};

void swap(GetTablesExtRequest &a, GetTablesExtRequest &b);

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() : tblName(), accessType(0) {
  }

  virtual ~ExtendedTableInfo() noexcept;
  std::string tblName;
  int32_t accessType;
  std::vector<std::string>  requiredReadCapabilities;
  std::vector<std::string>  requiredWriteCapabilities;

  _ExtendedTableInfo__isset __isset;

  void __set_tblName(const std::string& val);

  void __set_accessType(const int32_t val);

  void __set_requiredReadCapabilities(const std::vector<std::string> & val);

  void __set_requiredWriteCapabilities(const std::vector<std::string> & val);

  bool 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;
  }
  bool operator != (const ExtendedTableInfo &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ExtendedTableInfo & ) 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;
};

void swap(ExtendedTableInfo &a, ExtendedTableInfo &b);

std::ostream& operator<<(std::ostream& out, const ExtendedTableInfo& 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() : name(), catalogName(), processorIdentifier() {
  }

  virtual ~GetDatabaseRequest() noexcept;
  std::string name;
  std::string catalogName;
  std::vector<std::string>  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<std::string> & val);

  void __set_processorIdentifier(const std::string& val);

  bool 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;
  }
  bool operator != (const GetDatabaseRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetDatabaseRequest & ) 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;
};

void swap(GetDatabaseRequest &a, GetDatabaseRequest &b);

std::ostream& operator<<(std::ostream& out, const GetDatabaseRequest& obj);


class CmRecycleRequest : public virtual ::apache::thrift::TBase {
 public:

  CmRecycleRequest(const CmRecycleRequest&);
  CmRecycleRequest& operator=(const CmRecycleRequest&);
  CmRecycleRequest() : dataPath(), purge(0) {
  }

  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
  {
    if (!(dataPath == rhs.dataPath))
      return false;
    if (!(purge == rhs.purge))
      return false;
    return true;
  }
  bool operator != (const CmRecycleRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const CmRecycleRequest & ) 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;
};

void swap(CmRecycleRequest &a, CmRecycleRequest &b);

std::ostream& operator<<(std::ostream& out, const CmRecycleRequest& obj);


class CmRecycleResponse : public virtual ::apache::thrift::TBase {
 public:

  CmRecycleResponse(const CmRecycleResponse&);
  CmRecycleResponse& operator=(const CmRecycleResponse&);
  CmRecycleResponse() {
  }

  virtual ~CmRecycleResponse() noexcept;

  bool operator == (const CmRecycleResponse & /* rhs */) const
  {
    return true;
  }
  bool operator != (const CmRecycleResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const CmRecycleResponse & ) 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;
};

void swap(CmRecycleResponse &a, CmRecycleResponse &b);

std::ostream& operator<<(std::ostream& out, const CmRecycleResponse& obj);

typedef struct _TableMeta__isset {
  _TableMeta__isset() : comments(false), catName(false) {}
  bool comments :1;
  bool catName :1;
} _TableMeta__isset;

class TableMeta : public virtual ::apache::thrift::TBase {
 public:

  TableMeta(const TableMeta&);
  TableMeta& operator=(const TableMeta&);
  TableMeta() : dbName(), tableName(), tableType(), comments(), catName() {
  }

  virtual ~TableMeta() noexcept;
  std::string dbName;
  std::string tableName;
  std::string tableType;
  std::string comments;
  std::string catName;

  _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);

  bool 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;
    return true;
  }
  bool operator != (const TableMeta &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TableMeta & ) 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;
};

void swap(TableMeta &a, TableMeta &b);

std::ostream& operator<<(std::ostream& out, const TableMeta& obj);


class Materialization : public virtual ::apache::thrift::TBase {
 public:

  Materialization(const Materialization&);
  Materialization& operator=(const Materialization&);
  Materialization() : sourceTablesUpdateDeleteModified(0) {
  }

  virtual ~Materialization() noexcept;
  bool sourceTablesUpdateDeleteModified;

  void __set_sourceTablesUpdateDeleteModified(const bool val);

  bool operator == (const Materialization & rhs) const
  {
    if (!(sourceTablesUpdateDeleteModified == rhs.sourceTablesUpdateDeleteModified))
      return false;
    return true;
  }
  bool operator != (const Materialization &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Materialization & ) 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;
};

void swap(Materialization &a, Materialization &b);

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() : name(), status((WMResourcePlanStatus::type)0), queryParallelism(0), defaultPoolPath(), ns() {
  }

  virtual ~WMResourcePlan() noexcept;
  std::string name;
  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
  {
    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;
  }
  bool operator != (const WMResourcePlan &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMResourcePlan & ) 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;
};

void swap(WMResourcePlan &a, WMResourcePlan &b);

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() : name(), status((WMResourcePlanStatus::type)0), queryParallelism(0), isSetQueryParallelism(0), defaultPoolPath(), isSetDefaultPoolPath(0), ns() {
  }

  virtual ~WMNullableResourcePlan() noexcept;
  std::string name;
  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
  {
    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;
  }
  bool operator != (const WMNullableResourcePlan &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMNullableResourcePlan & ) 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;
};

void swap(WMNullableResourcePlan &a, WMNullableResourcePlan &b);

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() : resourcePlanName(), poolPath(), allocFraction(0), queryParallelism(0), schedulingPolicy(), ns() {
  }

  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
  {
    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;
  }
  bool operator != (const WMPool &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMPool & ) 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;
};

void swap(WMPool &a, WMPool &b);

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() : resourcePlanName(), poolPath(), allocFraction(0), queryParallelism(0), schedulingPolicy(), isSetSchedulingPolicy(0), ns() {
  }

  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
  {
    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;
  }
  bool operator != (const WMNullablePool &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMNullablePool & ) 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;
};

void swap(WMNullablePool &a, WMNullablePool &b);

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() : resourcePlanName(), triggerName(), triggerExpression(), actionExpression(), isInUnmanaged(0), ns() {
  }

  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
  {
    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;
  }
  bool operator != (const WMTrigger &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMTrigger & ) 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;
};

void swap(WMTrigger &a, WMTrigger &b);

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() : resourcePlanName(), entityType(), entityName(), poolPath(), ordering(0), ns() {
  }

  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
  {
    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;
  }
  bool operator != (const WMMapping &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMMapping & ) 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;
};

void swap(WMMapping &a, WMMapping &b);

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() : pool(), trigger(), ns() {
  }

  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
  {
    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;
  }
  bool operator != (const WMPoolTrigger &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMPoolTrigger & ) 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;
};

void swap(WMPoolTrigger &a, WMPoolTrigger &b);

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() {
  }

  virtual ~WMFullResourcePlan() noexcept;
  WMResourcePlan plan;
  std::vector<WMPool>  pools;
  std::vector<WMMapping>  mappings;
  std::vector<WMTrigger>  triggers;
  std::vector<WMPoolTrigger>  poolTriggers;

  _WMFullResourcePlan__isset __isset;

  void __set_plan(const WMResourcePlan& val);

  void __set_pools(const std::vector<WMPool> & val);

  void __set_mappings(const std::vector<WMMapping> & val);

  void __set_triggers(const std::vector<WMTrigger> & val);

  void __set_poolTriggers(const std::vector<WMPoolTrigger> & val);

  bool 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;
  }
  bool operator != (const WMFullResourcePlan &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMFullResourcePlan & ) 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;
};

void swap(WMFullResourcePlan &a, WMFullResourcePlan &b);

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() : copyFrom() {
  }

  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
  {
    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;
  }
  bool operator != (const WMCreateResourcePlanRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMCreateResourcePlanRequest & ) 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;
};

void swap(WMCreateResourcePlanRequest &a, WMCreateResourcePlanRequest &b);

std::ostream& operator<<(std::ostream& out, const WMCreateResourcePlanRequest& obj);


class WMCreateResourcePlanResponse : public virtual ::apache::thrift::TBase {
 public:

  WMCreateResourcePlanResponse(const WMCreateResourcePlanResponse&);
  WMCreateResourcePlanResponse& operator=(const WMCreateResourcePlanResponse&);
  WMCreateResourcePlanResponse() {
  }

  virtual ~WMCreateResourcePlanResponse() noexcept;

  bool operator == (const WMCreateResourcePlanResponse & /* rhs */) const
  {
    return true;
  }
  bool operator != (const WMCreateResourcePlanResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMCreateResourcePlanResponse & ) 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;
};

void swap(WMCreateResourcePlanResponse &a, WMCreateResourcePlanResponse &b);

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() : ns() {
  }

  virtual ~WMGetActiveResourcePlanRequest() noexcept;
  std::string ns;

  _WMGetActiveResourcePlanRequest__isset __isset;

  void __set_ns(const std::string& val);

  bool operator == (const WMGetActiveResourcePlanRequest & rhs) const
  {
    if (__isset.ns != rhs.__isset.ns)
      return false;
    else if (__isset.ns && !(ns == rhs.ns))
      return false;
    return true;
  }
  bool operator != (const WMGetActiveResourcePlanRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMGetActiveResourcePlanRequest & ) 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;
};

void swap(WMGetActiveResourcePlanRequest &a, WMGetActiveResourcePlanRequest &b);

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() {
  }

  virtual ~WMGetActiveResourcePlanResponse() noexcept;
  WMFullResourcePlan resourcePlan;

  _WMGetActiveResourcePlanResponse__isset __isset;

  void __set_resourcePlan(const WMFullResourcePlan& val);

  bool operator == (const WMGetActiveResourcePlanResponse & rhs) const
  {
    if (__isset.resourcePlan != rhs.__isset.resourcePlan)
      return false;
    else if (__isset.resourcePlan && !(resourcePlan == rhs.resourcePlan))
      return false;
    return true;
  }
  bool operator != (const WMGetActiveResourcePlanResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMGetActiveResourcePlanResponse & ) 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;
};

void swap(WMGetActiveResourcePlanResponse &a, WMGetActiveResourcePlanResponse &b);

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() : resourcePlanName(), ns() {
  }

  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
  {
    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;
  }
  bool operator != (const WMGetResourcePlanRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMGetResourcePlanRequest & ) 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;
};

void swap(WMGetResourcePlanRequest &a, WMGetResourcePlanRequest &b);

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() {
  }

  virtual ~WMGetResourcePlanResponse() noexcept;
  WMFullResourcePlan resourcePlan;

  _WMGetResourcePlanResponse__isset __isset;

  void __set_resourcePlan(const WMFullResourcePlan& val);

  bool operator == (const WMGetResourcePlanResponse & rhs) const
  {
    if (__isset.resourcePlan != rhs.__isset.resourcePlan)
      return false;
    else if (__isset.resourcePlan && !(resourcePlan == rhs.resourcePlan))
      return false;
    return true;
  }
  bool operator != (const WMGetResourcePlanResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMGetResourcePlanResponse & ) 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;
};

void swap(WMGetResourcePlanResponse &a, WMGetResourcePlanResponse &b);

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() : ns() {
  }

  virtual ~WMGetAllResourcePlanRequest() noexcept;
  std::string ns;

  _WMGetAllResourcePlanRequest__isset __isset;

  void __set_ns(const std::string& val);

  bool operator == (const WMGetAllResourcePlanRequest & rhs) const
  {
    if (__isset.ns != rhs.__isset.ns)
      return false;
    else if (__isset.ns && !(ns == rhs.ns))
      return false;
    return true;
  }
  bool operator != (const WMGetAllResourcePlanRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMGetAllResourcePlanRequest & ) 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;
};

void swap(WMGetAllResourcePlanRequest &a, WMGetAllResourcePlanRequest &b);

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() {
  }

  virtual ~WMGetAllResourcePlanResponse() noexcept;
  std::vector<WMResourcePlan>  resourcePlans;

  _WMGetAllResourcePlanResponse__isset __isset;

  void __set_resourcePlans(const std::vector<WMResourcePlan> & val);

  bool operator == (const WMGetAllResourcePlanResponse & rhs) const
  {
    if (__isset.resourcePlans != rhs.__isset.resourcePlans)
      return false;
    else if (__isset.resourcePlans && !(resourcePlans == rhs.resourcePlans))
      return false;
    return true;
  }
  bool operator != (const WMGetAllResourcePlanResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMGetAllResourcePlanResponse & ) 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;
};

void swap(WMGetAllResourcePlanResponse &a, WMGetAllResourcePlanResponse &b);

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() : resourcePlanName(), isEnableAndActivate(0), isForceDeactivate(0), isReplace(0), ns() {
  }

  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
  {
    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;
  }
  bool operator != (const WMAlterResourcePlanRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMAlterResourcePlanRequest & ) 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;
};

void swap(WMAlterResourcePlanRequest &a, WMAlterResourcePlanRequest &b);

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() {
  }

  virtual ~WMAlterResourcePlanResponse() noexcept;
  WMFullResourcePlan fullResourcePlan;

  _WMAlterResourcePlanResponse__isset __isset;

  void __set_fullResourcePlan(const WMFullResourcePlan& val);

  bool operator == (const WMAlterResourcePlanResponse & rhs) const
  {
    if (__isset.fullResourcePlan != rhs.__isset.fullResourcePlan)
      return false;
    else if (__isset.fullResourcePlan && !(fullResourcePlan == rhs.fullResourcePlan))
      return false;
    return true;
  }
  bool operator != (const WMAlterResourcePlanResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMAlterResourcePlanResponse & ) 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;
};

void swap(WMAlterResourcePlanResponse &a, WMAlterResourcePlanResponse &b);

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() : resourcePlanName(), ns() {
  }

  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
  {
    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;
  }
  bool operator != (const WMValidateResourcePlanRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMValidateResourcePlanRequest & ) 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;
};

void swap(WMValidateResourcePlanRequest &a, WMValidateResourcePlanRequest &b);

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() {
  }

  virtual ~WMValidateResourcePlanResponse() noexcept;
  std::vector<std::string>  errors;
  std::vector<std::string>  warnings;

  _WMValidateResourcePlanResponse__isset __isset;

  void __set_errors(const std::vector<std::string> & val);

  void __set_warnings(const std::vector<std::string> & val);

  bool 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;
  }
  bool operator != (const WMValidateResourcePlanResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMValidateResourcePlanResponse & ) 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;
};

void swap(WMValidateResourcePlanResponse &a, WMValidateResourcePlanResponse &b);

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() : resourcePlanName(), ns() {
  }

  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
  {
    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;
  }
  bool operator != (const WMDropResourcePlanRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMDropResourcePlanRequest & ) 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;
};

void swap(WMDropResourcePlanRequest &a, WMDropResourcePlanRequest &b);

std::ostream& operator<<(std::ostream& out, const WMDropResourcePlanRequest& obj);


class WMDropResourcePlanResponse : public virtual ::apache::thrift::TBase {
 public:

  WMDropResourcePlanResponse(const WMDropResourcePlanResponse&);
  WMDropResourcePlanResponse& operator=(const WMDropResourcePlanResponse&);
  WMDropResourcePlanResponse() {
  }

  virtual ~WMDropResourcePlanResponse() noexcept;

  bool operator == (const WMDropResourcePlanResponse & /* rhs */) const
  {
    return true;
  }
  bool operator != (const WMDropResourcePlanResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMDropResourcePlanResponse & ) 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;
};

void swap(WMDropResourcePlanResponse &a, WMDropResourcePlanResponse &b);

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() {
  }

  virtual ~WMCreateTriggerRequest() noexcept;
  WMTrigger trigger;

  _WMCreateTriggerRequest__isset __isset;

  void __set_trigger(const WMTrigger& val);

  bool operator == (const WMCreateTriggerRequest & rhs) const
  {
    if (__isset.trigger != rhs.__isset.trigger)
      return false;
    else if (__isset.trigger && !(trigger == rhs.trigger))
      return false;
    return true;
  }
  bool operator != (const WMCreateTriggerRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMCreateTriggerRequest & ) 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;
};

void swap(WMCreateTriggerRequest &a, WMCreateTriggerRequest &b);

std::ostream& operator<<(std::ostream& out, const WMCreateTriggerRequest& obj);


class WMCreateTriggerResponse : public virtual ::apache::thrift::TBase {
 public:

  WMCreateTriggerResponse(const WMCreateTriggerResponse&);
  WMCreateTriggerResponse& operator=(const WMCreateTriggerResponse&);
  WMCreateTriggerResponse() {
  }

  virtual ~WMCreateTriggerResponse() noexcept;

  bool operator == (const WMCreateTriggerResponse & /* rhs */) const
  {
    return true;
  }
  bool operator != (const WMCreateTriggerResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMCreateTriggerResponse & ) 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;
};

void swap(WMCreateTriggerResponse &a, WMCreateTriggerResponse &b);

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() {
  }

  virtual ~WMAlterTriggerRequest() noexcept;
  WMTrigger trigger;

  _WMAlterTriggerRequest__isset __isset;

  void __set_trigger(const WMTrigger& val);

  bool operator == (const WMAlterTriggerRequest & rhs) const
  {
    if (__isset.trigger != rhs.__isset.trigger)
      return false;
    else if (__isset.trigger && !(trigger == rhs.trigger))
      return false;
    return true;
  }
  bool operator != (const WMAlterTriggerRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMAlterTriggerRequest & ) 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;
};

void swap(WMAlterTriggerRequest &a, WMAlterTriggerRequest &b);

std::ostream& operator<<(std::ostream& out, const WMAlterTriggerRequest& obj);


class WMAlterTriggerResponse : public virtual ::apache::thrift::TBase {
 public:

  WMAlterTriggerResponse(const WMAlterTriggerResponse&);
  WMAlterTriggerResponse& operator=(const WMAlterTriggerResponse&);
  WMAlterTriggerResponse() {
  }

  virtual ~WMAlterTriggerResponse() noexcept;

  bool operator == (const WMAlterTriggerResponse & /* rhs */) const
  {
    return true;
  }
  bool operator != (const WMAlterTriggerResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMAlterTriggerResponse & ) 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;
};

void swap(WMAlterTriggerResponse &a, WMAlterTriggerResponse &b);

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() : resourcePlanName(), triggerName(), ns() {
  }

  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
  {
    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;
  }
  bool operator != (const WMDropTriggerRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMDropTriggerRequest & ) 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;
};

void swap(WMDropTriggerRequest &a, WMDropTriggerRequest &b);

std::ostream& operator<<(std::ostream& out, const WMDropTriggerRequest& obj);


class WMDropTriggerResponse : public virtual ::apache::thrift::TBase {
 public:

  WMDropTriggerResponse(const WMDropTriggerResponse&);
  WMDropTriggerResponse& operator=(const WMDropTriggerResponse&);
  WMDropTriggerResponse() {
  }

  virtual ~WMDropTriggerResponse() noexcept;

  bool operator == (const WMDropTriggerResponse & /* rhs */) const
  {
    return true;
  }
  bool operator != (const WMDropTriggerResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMDropTriggerResponse & ) 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;
};

void swap(WMDropTriggerResponse &a, WMDropTriggerResponse &b);

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() : resourcePlanName(), ns() {
  }

  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
  {
    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;
  }
  bool operator != (const WMGetTriggersForResourePlanRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMGetTriggersForResourePlanRequest & ) 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;
};

void swap(WMGetTriggersForResourePlanRequest &a, WMGetTriggersForResourePlanRequest &b);

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() {
  }

  virtual ~WMGetTriggersForResourePlanResponse() noexcept;
  std::vector<WMTrigger>  triggers;

  _WMGetTriggersForResourePlanResponse__isset __isset;

  void __set_triggers(const std::vector<WMTrigger> & val);

  bool operator == (const WMGetTriggersForResourePlanResponse & rhs) const
  {
    if (__isset.triggers != rhs.__isset.triggers)
      return false;
    else if (__isset.triggers && !(triggers == rhs.triggers))
      return false;
    return true;
  }
  bool operator != (const WMGetTriggersForResourePlanResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMGetTriggersForResourePlanResponse & ) 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;
};

void swap(WMGetTriggersForResourePlanResponse &a, WMGetTriggersForResourePlanResponse &b);

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() {
  }

  virtual ~WMCreatePoolRequest() noexcept;
  WMPool pool;

  _WMCreatePoolRequest__isset __isset;

  void __set_pool(const WMPool& val);

  bool operator == (const WMCreatePoolRequest & rhs) const
  {
    if (__isset.pool != rhs.__isset.pool)
      return false;
    else if (__isset.pool && !(pool == rhs.pool))
      return false;
    return true;
  }
  bool operator != (const WMCreatePoolRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMCreatePoolRequest & ) 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;
};

void swap(WMCreatePoolRequest &a, WMCreatePoolRequest &b);

std::ostream& operator<<(std::ostream& out, const WMCreatePoolRequest& obj);


class WMCreatePoolResponse : public virtual ::apache::thrift::TBase {
 public:

  WMCreatePoolResponse(const WMCreatePoolResponse&);
  WMCreatePoolResponse& operator=(const WMCreatePoolResponse&);
  WMCreatePoolResponse() {
  }

  virtual ~WMCreatePoolResponse() noexcept;

  bool operator == (const WMCreatePoolResponse & /* rhs */) const
  {
    return true;
  }
  bool operator != (const WMCreatePoolResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMCreatePoolResponse & ) 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;
};

void swap(WMCreatePoolResponse &a, WMCreatePoolResponse &b);

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() : poolPath() {
  }

  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
  {
    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;
  }
  bool operator != (const WMAlterPoolRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMAlterPoolRequest & ) 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;
};

void swap(WMAlterPoolRequest &a, WMAlterPoolRequest &b);

std::ostream& operator<<(std::ostream& out, const WMAlterPoolRequest& obj);


class WMAlterPoolResponse : public virtual ::apache::thrift::TBase {
 public:

  WMAlterPoolResponse(const WMAlterPoolResponse&);
  WMAlterPoolResponse& operator=(const WMAlterPoolResponse&);
  WMAlterPoolResponse() {
  }

  virtual ~WMAlterPoolResponse() noexcept;

  bool operator == (const WMAlterPoolResponse & /* rhs */) const
  {
    return true;
  }
  bool operator != (const WMAlterPoolResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMAlterPoolResponse & ) 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;
};

void swap(WMAlterPoolResponse &a, WMAlterPoolResponse &b);

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() : resourcePlanName(), poolPath(), ns() {
  }

  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
  {
    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;
  }
  bool operator != (const WMDropPoolRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMDropPoolRequest & ) 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;
};

void swap(WMDropPoolRequest &a, WMDropPoolRequest &b);

std::ostream& operator<<(std::ostream& out, const WMDropPoolRequest& obj);


class WMDropPoolResponse : public virtual ::apache::thrift::TBase {
 public:

  WMDropPoolResponse(const WMDropPoolResponse&);
  WMDropPoolResponse& operator=(const WMDropPoolResponse&);
  WMDropPoolResponse() {
  }

  virtual ~WMDropPoolResponse() noexcept;

  bool operator == (const WMDropPoolResponse & /* rhs */) const
  {
    return true;
  }
  bool operator != (const WMDropPoolResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMDropPoolResponse & ) 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;
};

void swap(WMDropPoolResponse &a, WMDropPoolResponse &b);

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() : update(0) {
  }

  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
  {
    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;
  }
  bool operator != (const WMCreateOrUpdateMappingRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMCreateOrUpdateMappingRequest & ) 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;
};

void swap(WMCreateOrUpdateMappingRequest &a, WMCreateOrUpdateMappingRequest &b);

std::ostream& operator<<(std::ostream& out, const WMCreateOrUpdateMappingRequest& obj);


class WMCreateOrUpdateMappingResponse : public virtual ::apache::thrift::TBase {
 public:

  WMCreateOrUpdateMappingResponse(const WMCreateOrUpdateMappingResponse&);
  WMCreateOrUpdateMappingResponse& operator=(const WMCreateOrUpdateMappingResponse&);
  WMCreateOrUpdateMappingResponse() {
  }

  virtual ~WMCreateOrUpdateMappingResponse() noexcept;

  bool operator == (const WMCreateOrUpdateMappingResponse & /* rhs */) const
  {
    return true;
  }
  bool operator != (const WMCreateOrUpdateMappingResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMCreateOrUpdateMappingResponse & ) 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;
};

void swap(WMCreateOrUpdateMappingResponse &a, WMCreateOrUpdateMappingResponse &b);

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() {
  }

  virtual ~WMDropMappingRequest() noexcept;
  WMMapping mapping;

  _WMDropMappingRequest__isset __isset;

  void __set_mapping(const WMMapping& val);

  bool operator == (const WMDropMappingRequest & rhs) const
  {
    if (__isset.mapping != rhs.__isset.mapping)
      return false;
    else if (__isset.mapping && !(mapping == rhs.mapping))
      return false;
    return true;
  }
  bool operator != (const WMDropMappingRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMDropMappingRequest & ) 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;
};

void swap(WMDropMappingRequest &a, WMDropMappingRequest &b);

std::ostream& operator<<(std::ostream& out, const WMDropMappingRequest& obj);


class WMDropMappingResponse : public virtual ::apache::thrift::TBase {
 public:

  WMDropMappingResponse(const WMDropMappingResponse&);
  WMDropMappingResponse& operator=(const WMDropMappingResponse&);
  WMDropMappingResponse() {
  }

  virtual ~WMDropMappingResponse() noexcept;

  bool operator == (const WMDropMappingResponse & /* rhs */) const
  {
    return true;
  }
  bool operator != (const WMDropMappingResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMDropMappingResponse & ) 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;
};

void swap(WMDropMappingResponse &a, WMDropMappingResponse &b);

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() : resourcePlanName(), triggerName(), poolPath(), drop(0), ns() {
  }

  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
  {
    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;
  }
  bool operator != (const WMCreateOrDropTriggerToPoolMappingRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMCreateOrDropTriggerToPoolMappingRequest & ) 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;
};

void swap(WMCreateOrDropTriggerToPoolMappingRequest &a, WMCreateOrDropTriggerToPoolMappingRequest &b);

std::ostream& operator<<(std::ostream& out, const WMCreateOrDropTriggerToPoolMappingRequest& obj);


class WMCreateOrDropTriggerToPoolMappingResponse : public virtual ::apache::thrift::TBase {
 public:

  WMCreateOrDropTriggerToPoolMappingResponse(const WMCreateOrDropTriggerToPoolMappingResponse&);
  WMCreateOrDropTriggerToPoolMappingResponse& operator=(const WMCreateOrDropTriggerToPoolMappingResponse&);
  WMCreateOrDropTriggerToPoolMappingResponse() {
  }

  virtual ~WMCreateOrDropTriggerToPoolMappingResponse() noexcept;

  bool operator == (const WMCreateOrDropTriggerToPoolMappingResponse & /* rhs */) const
  {
    return true;
  }
  bool operator != (const WMCreateOrDropTriggerToPoolMappingResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const WMCreateOrDropTriggerToPoolMappingResponse & ) 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;
};

void swap(WMCreateOrDropTriggerToPoolMappingResponse &a, WMCreateOrDropTriggerToPoolMappingResponse &b);

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() : schemaType((SchemaType::type)0), name(), catName(), dbName(), compatibility((SchemaCompatibility::type)0), validationLevel((SchemaValidation::type)0), canEvolve(0), schemaGroup(), description() {
  }

  virtual ~ISchema() noexcept;
  SchemaType::type schemaType;
  std::string name;
  std::string catName;
  std::string dbName;
  SchemaCompatibility::type compatibility;
  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
  {
    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;
  }
  bool operator != (const ISchema &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ISchema & ) 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;
};

void swap(ISchema &a, ISchema &b);

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() : catName(), dbName(), schemaName() {
  }

  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
  {
    if (!(catName == rhs.catName))
      return false;
    if (!(dbName == rhs.dbName))
      return false;
    if (!(schemaName == rhs.schemaName))
      return false;
    return true;
  }
  bool operator != (const ISchemaName &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ISchemaName & ) 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;
};

void swap(ISchemaName &a, ISchemaName &b);

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() {
  }

  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
  {
    if (!(name == rhs.name))
      return false;
    if (!(newSchema == rhs.newSchema))
      return false;
    return true;
  }
  bool operator != (const AlterISchemaRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const AlterISchemaRequest & ) 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;
};

void swap(AlterISchemaRequest &a, AlterISchemaRequest &b);

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() : version(0), createdAt(0), state((SchemaVersionState::type)0), description(), schemaText(), fingerprint(), name() {
  }

  virtual ~SchemaVersion() noexcept;
  ISchemaName schema;
  int32_t version;
  int64_t createdAt;
  std::vector<FieldSchema>  cols;
  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<FieldSchema> & 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
  {
    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;
  }
  bool operator != (const SchemaVersion &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const SchemaVersion & ) 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;
};

void swap(SchemaVersion &a, SchemaVersion &b);

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() : version(0) {
  }

  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
  {
    if (!(schema == rhs.schema))
      return false;
    if (!(version == rhs.version))
      return false;
    return true;
  }
  bool operator != (const SchemaVersionDescriptor &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const SchemaVersionDescriptor & ) 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;
};

void swap(SchemaVersionDescriptor &a, SchemaVersionDescriptor &b);

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() : colName(), colNamespace(), type() {
  }

  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
  {
    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;
  }
  bool operator != (const FindSchemasByColsRqst &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const FindSchemasByColsRqst & ) 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;
};

void swap(FindSchemasByColsRqst &a, FindSchemasByColsRqst &b);

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() {
  }

  virtual ~FindSchemasByColsResp() noexcept;
  std::vector<SchemaVersionDescriptor>  schemaVersions;

  _FindSchemasByColsResp__isset __isset;

  void __set_schemaVersions(const std::vector<SchemaVersionDescriptor> & val);

  bool operator == (const FindSchemasByColsResp & rhs) const
  {
    if (!(schemaVersions == rhs.schemaVersions))
      return false;
    return true;
  }
  bool operator != (const FindSchemasByColsResp &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const FindSchemasByColsResp & ) 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;
};

void swap(FindSchemasByColsResp &a, FindSchemasByColsResp &b);

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() : serdeName() {
  }

  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
  {
    if (!(schemaVersion == rhs.schemaVersion))
      return false;
    if (!(serdeName == rhs.serdeName))
      return false;
    return true;
  }
  bool operator != (const MapSchemaVersionToSerdeRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const MapSchemaVersionToSerdeRequest & ) 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;
};

void swap(MapSchemaVersionToSerdeRequest &a, MapSchemaVersionToSerdeRequest &b);

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() : state((SchemaVersionState::type)0) {
  }

  virtual ~SetSchemaVersionStateRequest() noexcept;
  SchemaVersionDescriptor schemaVersion;
  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
  {
    if (!(schemaVersion == rhs.schemaVersion))
      return false;
    if (!(state == rhs.state))
      return false;
    return true;
  }
  bool operator != (const SetSchemaVersionStateRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const SetSchemaVersionStateRequest & ) 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;
};

void swap(SetSchemaVersionStateRequest &a, SetSchemaVersionStateRequest &b);

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() : serdeName() {
  }

  virtual ~GetSerdeRequest() noexcept;
  std::string serdeName;

  _GetSerdeRequest__isset __isset;

  void __set_serdeName(const std::string& val);

  bool operator == (const GetSerdeRequest & rhs) const
  {
    if (!(serdeName == rhs.serdeName))
      return false;
    return true;
  }
  bool operator != (const GetSerdeRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetSerdeRequest & ) 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;
};

void swap(GetSerdeRequest &a, GetSerdeRequest &b);

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() : createTime(0), weight(0), payload() {
  }

  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
  {
    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;
  }
  bool operator != (const RuntimeStat &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const RuntimeStat & ) 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;
};

void swap(RuntimeStat &a, RuntimeStat &b);

std::ostream& operator<<(std::ostream& out, const RuntimeStat& obj);


class GetRuntimeStatsRequest : public virtual ::apache::thrift::TBase {
 public:

  GetRuntimeStatsRequest(const GetRuntimeStatsRequest&);
  GetRuntimeStatsRequest& operator=(const GetRuntimeStatsRequest&);
  GetRuntimeStatsRequest() : maxWeight(0), maxCreateTime(0) {
  }

  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
  {
    if (!(maxWeight == rhs.maxWeight))
      return false;
    if (!(maxCreateTime == rhs.maxCreateTime))
      return false;
    return true;
  }
  bool operator != (const GetRuntimeStatsRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetRuntimeStatsRequest & ) 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;
};

void swap(GetRuntimeStatsRequest &a, GetRuntimeStatsRequest &b);

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() : processorIdentifier() {
  }

  virtual ~CreateTableRequest() noexcept;
  Table table;
  EnvironmentContext envContext;
  std::vector<SQLPrimaryKey>  primaryKeys;
  std::vector<SQLForeignKey>  foreignKeys;
  std::vector<SQLUniqueConstraint>  uniqueConstraints;
  std::vector<SQLNotNullConstraint>  notNullConstraints;
  std::vector<SQLDefaultConstraint>  defaultConstraints;
  std::vector<SQLCheckConstraint>  checkConstraints;
  std::vector<std::string>  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<SQLPrimaryKey> & val);

  void __set_foreignKeys(const std::vector<SQLForeignKey> & val);

  void __set_uniqueConstraints(const std::vector<SQLUniqueConstraint> & val);

  void __set_notNullConstraints(const std::vector<SQLNotNullConstraint> & val);

  void __set_defaultConstraints(const std::vector<SQLDefaultConstraint> & val);

  void __set_checkConstraints(const std::vector<SQLCheckConstraint> & val);

  void __set_processorCapabilities(const std::vector<std::string> & val);

  void __set_processorIdentifier(const std::string& val);

  bool 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;
  }
  bool operator != (const CreateTableRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const CreateTableRequest & ) 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;
};

void swap(CreateTableRequest &a, CreateTableRequest &b);

std::ostream& operator<<(std::ostream& out, const CreateTableRequest& obj);


class ScheduledQueryPollRequest : public virtual ::apache::thrift::TBase {
 public:

  ScheduledQueryPollRequest(const ScheduledQueryPollRequest&);
  ScheduledQueryPollRequest& operator=(const ScheduledQueryPollRequest&);
  ScheduledQueryPollRequest() : clusterNamespace() {
  }

  virtual ~ScheduledQueryPollRequest() noexcept;
  std::string clusterNamespace;

  void __set_clusterNamespace(const std::string& val);

  bool operator == (const ScheduledQueryPollRequest & rhs) const
  {
    if (!(clusterNamespace == rhs.clusterNamespace))
      return false;
    return true;
  }
  bool operator != (const ScheduledQueryPollRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ScheduledQueryPollRequest & ) 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;
};

void swap(ScheduledQueryPollRequest &a, ScheduledQueryPollRequest &b);

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() : scheduleName(), clusterNamespace() {
  }

  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
  {
    if (!(scheduleName == rhs.scheduleName))
      return false;
    if (!(clusterNamespace == rhs.clusterNamespace))
      return false;
    return true;
  }
  bool operator != (const ScheduledQueryKey &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ScheduledQueryKey & ) 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;
};

void swap(ScheduledQueryKey &a, ScheduledQueryKey &b);

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() : executionId(0), query(), user() {
  }

  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
  {
    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;
  }
  bool operator != (const ScheduledQueryPollResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ScheduledQueryPollResponse & ) 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;
};

void swap(ScheduledQueryPollResponse &a, ScheduledQueryPollResponse &b);

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() : enabled(0), schedule(), user(), query(), nextExecution(0) {
  }

  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
  {
    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;
  }
  bool operator != (const ScheduledQuery &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ScheduledQuery & ) 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;
};

void swap(ScheduledQuery &a, ScheduledQuery &b);

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() : type((ScheduledQueryMaintenanceRequestType::type)0) {
  }

  virtual ~ScheduledQueryMaintenanceRequest() noexcept;
  ScheduledQueryMaintenanceRequestType::type type;
  ScheduledQuery scheduledQuery;

  void __set_type(const ScheduledQueryMaintenanceRequestType::type val);

  void __set_scheduledQuery(const ScheduledQuery& val);

  bool operator == (const ScheduledQueryMaintenanceRequest & rhs) const
  {
    if (!(type == rhs.type))
      return false;
    if (!(scheduledQuery == rhs.scheduledQuery))
      return false;
    return true;
  }
  bool operator != (const ScheduledQueryMaintenanceRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ScheduledQueryMaintenanceRequest & ) 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;
};

void swap(ScheduledQueryMaintenanceRequest &a, ScheduledQueryMaintenanceRequest &b);

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() : scheduledExecutionId(0), state((QueryState::type)0), executorQueryId(), errorMessage() {
  }

  virtual ~ScheduledQueryProgressInfo() noexcept;
  int64_t scheduledExecutionId;
  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
  {
    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;
  }
  bool operator != (const ScheduledQueryProgressInfo &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ScheduledQueryProgressInfo & ) 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;
};

void swap(ScheduledQueryProgressInfo &a, ScheduledQueryProgressInfo &b);

std::ostream& operator<<(std::ostream& out, const ScheduledQueryProgressInfo& obj);

typedef struct _AlterPartitionsRequest__isset {
  _AlterPartitionsRequest__isset() : catName(false), environmentContext(false), writeId(true), validWriteIdList(false) {}
  bool catName :1;
  bool environmentContext :1;
  bool writeId :1;
  bool validWriteIdList :1;
} _AlterPartitionsRequest__isset;

class AlterPartitionsRequest : public virtual ::apache::thrift::TBase {
 public:

  AlterPartitionsRequest(const AlterPartitionsRequest&);
  AlterPartitionsRequest& operator=(const AlterPartitionsRequest&);
  AlterPartitionsRequest() : catName(), dbName(), tableName(), writeId(-1LL), validWriteIdList() {
  }

  virtual ~AlterPartitionsRequest() noexcept;
  std::string catName;
  std::string dbName;
  std::string tableName;
  std::vector<Partition>  partitions;
  EnvironmentContext environmentContext;
  int64_t writeId;
  std::string validWriteIdList;

  _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<Partition> & val);

  void __set_environmentContext(const EnvironmentContext& val);

  void __set_writeId(const int64_t val);

  void __set_validWriteIdList(const std::string& val);

  bool 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;
    return true;
  }
  bool operator != (const AlterPartitionsRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const AlterPartitionsRequest & ) 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;
};

void swap(AlterPartitionsRequest &a, AlterPartitionsRequest &b);

std::ostream& operator<<(std::ostream& out, const AlterPartitionsRequest& obj);


class AlterPartitionsResponse : public virtual ::apache::thrift::TBase {
 public:

  AlterPartitionsResponse(const AlterPartitionsResponse&);
  AlterPartitionsResponse& operator=(const AlterPartitionsResponse&);
  AlterPartitionsResponse() {
  }

  virtual ~AlterPartitionsResponse() noexcept;

  bool operator == (const AlterPartitionsResponse & /* rhs */) const
  {
    return true;
  }
  bool operator != (const AlterPartitionsResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const AlterPartitionsResponse & ) 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;
};

void swap(AlterPartitionsResponse &a, AlterPartitionsResponse &b);

std::ostream& operator<<(std::ostream& out, const AlterPartitionsResponse& obj);

typedef struct _RenamePartitionRequest__isset {
  _RenamePartitionRequest__isset() : catName(false), validWriteIdList(false) {}
  bool catName :1;
  bool validWriteIdList :1;
} _RenamePartitionRequest__isset;

class RenamePartitionRequest : public virtual ::apache::thrift::TBase {
 public:

  RenamePartitionRequest(const RenamePartitionRequest&);
  RenamePartitionRequest& operator=(const RenamePartitionRequest&);
  RenamePartitionRequest() : catName(), dbName(), tableName(), validWriteIdList() {
  }

  virtual ~RenamePartitionRequest() noexcept;
  std::string catName;
  std::string dbName;
  std::string tableName;
  std::vector<std::string>  partVals;
  Partition newPart;
  std::string validWriteIdList;

  _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<std::string> & val);

  void __set_newPart(const Partition& val);

  void __set_validWriteIdList(const std::string& val);

  bool 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;
    return true;
  }
  bool operator != (const RenamePartitionRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const RenamePartitionRequest & ) 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;
};

void swap(RenamePartitionRequest &a, RenamePartitionRequest &b);

std::ostream& operator<<(std::ostream& out, const RenamePartitionRequest& obj);


class RenamePartitionResponse : public virtual ::apache::thrift::TBase {
 public:

  RenamePartitionResponse(const RenamePartitionResponse&);
  RenamePartitionResponse& operator=(const RenamePartitionResponse&);
  RenamePartitionResponse() {
  }

  virtual ~RenamePartitionResponse() noexcept;

  bool operator == (const RenamePartitionResponse & /* rhs */) const
  {
    return true;
  }
  bool operator != (const RenamePartitionResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const RenamePartitionResponse & ) 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;
};

void swap(RenamePartitionResponse &a, RenamePartitionResponse &b);

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) {}
  bool catName :1;
  bool environmentContext :1;
  bool writeId :1;
  bool validWriteIdList :1;
  bool processorCapabilities :1;
  bool processorIdentifier :1;
} _AlterTableRequest__isset;

class AlterTableRequest : public virtual ::apache::thrift::TBase {
 public:

  AlterTableRequest(const AlterTableRequest&);
  AlterTableRequest& operator=(const AlterTableRequest&);
  AlterTableRequest() : catName(), dbName(), tableName(), writeId(-1LL), validWriteIdList(), processorIdentifier() {
  }

  virtual ~AlterTableRequest() noexcept;
  std::string catName;
  std::string dbName;
  std::string tableName;
  Table table;
  EnvironmentContext environmentContext;
  int64_t writeId;
  std::string validWriteIdList;
  std::vector<std::string>  processorCapabilities;
  std::string processorIdentifier;

  _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<std::string> & val);

  void __set_processorIdentifier(const std::string& val);

  bool 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;
    return true;
  }
  bool operator != (const AlterTableRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const AlterTableRequest & ) 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;
};

void swap(AlterTableRequest &a, AlterTableRequest &b);

std::ostream& operator<<(std::ostream& out, const AlterTableRequest& obj);


class AlterTableResponse : public virtual ::apache::thrift::TBase {
 public:

  AlterTableResponse(const AlterTableResponse&);
  AlterTableResponse& operator=(const AlterTableResponse&);
  AlterTableResponse() {
  }

  virtual ~AlterTableResponse() noexcept;

  bool operator == (const AlterTableResponse & /* rhs */) const
  {
    return true;
  }
  bool operator != (const AlterTableResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const AlterTableResponse & ) 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;
};

void swap(AlterTableResponse &a, AlterTableResponse &b);

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() : filterMode((PartitionFilterMode::type)0) {
  }

  virtual ~GetPartitionsFilterSpec() noexcept;
  PartitionFilterMode::type filterMode;
  std::vector<std::string>  filters;

  _GetPartitionsFilterSpec__isset __isset;

  void __set_filterMode(const PartitionFilterMode::type val);

  void __set_filters(const std::vector<std::string> & val);

  bool 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;
  }
  bool operator != (const GetPartitionsFilterSpec &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetPartitionsFilterSpec & ) 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;
};

void swap(GetPartitionsFilterSpec &a, GetPartitionsFilterSpec &b);

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() {
  }

  virtual ~GetPartitionsResponse() noexcept;
  std::vector<PartitionSpec>  partitionSpec;

  _GetPartitionsResponse__isset __isset;

  void __set_partitionSpec(const std::vector<PartitionSpec> & val);

  bool operator == (const GetPartitionsResponse & rhs) const
  {
    if (!(partitionSpec == rhs.partitionSpec))
      return false;
    return true;
  }
  bool operator != (const GetPartitionsResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetPartitionsResponse & ) 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;
};

void swap(GetPartitionsResponse &a, GetPartitionsResponse &b);

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() : catName(), dbName(), tblName(), withAuth(0), user(), processorIdentifier(), validWriteIdList() {
  }

  virtual ~GetPartitionsRequest() noexcept;
  std::string catName;
  std::string dbName;
  std::string tblName;
  bool withAuth;
  std::string user;
  std::vector<std::string>  groupNames;
  GetProjectionsSpec projectionSpec;
  GetPartitionsFilterSpec filterSpec;
  std::vector<std::string>  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<std::string> & val);

  void __set_projectionSpec(const GetProjectionsSpec& val);

  void __set_filterSpec(const GetPartitionsFilterSpec& val);

  void __set_processorCapabilities(const std::vector<std::string> & val);

  void __set_processorIdentifier(const std::string& val);

  void __set_validWriteIdList(const std::string& val);

  bool 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;
  }
  bool operator != (const GetPartitionsRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetPartitionsRequest & ) 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;
};

void swap(GetPartitionsRequest &a, GetPartitionsRequest &b);

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() : catName(), dbName(), tblName(), validWriteIdList(), id(-1LL) {
  }

  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
  {
    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;
  }
  bool operator != (const GetFieldsRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetFieldsRequest & ) 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;
};

void swap(GetFieldsRequest &a, GetFieldsRequest &b);

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() {
  }

  virtual ~GetFieldsResponse() noexcept;
  std::vector<FieldSchema>  fields;

  void __set_fields(const std::vector<FieldSchema> & val);

  bool operator == (const GetFieldsResponse & rhs) const
  {
    if (!(fields == rhs.fields))
      return false;
    return true;
  }
  bool operator != (const GetFieldsResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetFieldsResponse & ) 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;
};

void swap(GetFieldsResponse &a, GetFieldsResponse &b);

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() : catName(), dbName(), tblName(), validWriteIdList(), id(-1LL) {
  }

  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
  {
    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;
  }
  bool operator != (const GetSchemaRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetSchemaRequest & ) 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;
};

void swap(GetSchemaRequest &a, GetSchemaRequest &b);

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() {
  }

  virtual ~GetSchemaResponse() noexcept;
  std::vector<FieldSchema>  fields;

  void __set_fields(const std::vector<FieldSchema> & val);

  bool operator == (const GetSchemaResponse & rhs) const
  {
    if (!(fields == rhs.fields))
      return false;
    return true;
  }
  bool operator != (const GetSchemaResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetSchemaResponse & ) 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;
};

void swap(GetSchemaResponse &a, GetSchemaResponse &b);

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() : catName(), dbName(), tblName(), validWriteIdList(), id(-1LL) {
  }

  virtual ~GetPartitionRequest() noexcept;
  std::string catName;
  std::string dbName;
  std::string tblName;
  std::vector<std::string>  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<std::string> & val);

  void __set_validWriteIdList(const std::string& val);

  void __set_id(const int64_t val);

  bool 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;
  }
  bool operator != (const GetPartitionRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetPartitionRequest & ) 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;
};

void swap(GetPartitionRequest &a, GetPartitionRequest &b);

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() {
  }

  virtual ~GetPartitionResponse() noexcept;
  Partition partition;

  void __set_partition(const Partition& val);

  bool operator == (const GetPartitionResponse & rhs) const
  {
    if (!(partition == rhs.partition))
      return false;
    return true;
  }
  bool operator != (const GetPartitionResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetPartitionResponse & ) 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;
};

void swap(GetPartitionResponse &a, GetPartitionResponse &b);

std::ostream& operator<<(std::ostream& out, const GetPartitionResponse& obj);

typedef struct _PartitionsRequest__isset {
  _PartitionsRequest__isset() : catName(false), maxParts(true), validWriteIdList(false), id(true) {}
  bool catName :1;
  bool maxParts :1;
  bool validWriteIdList :1;
  bool id :1;
} _PartitionsRequest__isset;

class PartitionsRequest : public virtual ::apache::thrift::TBase {
 public:

  PartitionsRequest(const PartitionsRequest&);
  PartitionsRequest& operator=(const PartitionsRequest&);
  PartitionsRequest() : catName(), dbName(), tblName(), maxParts(-1), validWriteIdList(), id(-1LL) {
  }

  virtual ~PartitionsRequest() noexcept;
  std::string catName;
  std::string dbName;
  std::string tblName;
  int16_t maxParts;
  std::string validWriteIdList;
  int64_t id;

  _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);

  bool 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;
    return true;
  }
  bool operator != (const PartitionsRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const PartitionsRequest & ) 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;
};

void swap(PartitionsRequest &a, PartitionsRequest &b);

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() {
  }

  virtual ~PartitionsResponse() noexcept;
  std::vector<Partition>  partitions;

  void __set_partitions(const std::vector<Partition> & val);

  bool operator == (const PartitionsResponse & rhs) const
  {
    if (!(partitions == rhs.partitions))
      return false;
    return true;
  }
  bool operator != (const PartitionsResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const PartitionsResponse & ) 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;
};

void swap(PartitionsResponse &a, PartitionsResponse &b);

std::ostream& operator<<(std::ostream& out, const PartitionsResponse& 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() : catName(), dbName(), tblName(), maxParts(-1), validWriteIdList(), id(-1LL) {
  }

  virtual ~GetPartitionNamesPsRequest() noexcept;
  std::string catName;
  std::string dbName;
  std::string tblName;
  std::vector<std::string>  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<std::string> & 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
  {
    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;
  }
  bool operator != (const GetPartitionNamesPsRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetPartitionNamesPsRequest & ) 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;
};

void swap(GetPartitionNamesPsRequest &a, GetPartitionNamesPsRequest &b);

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() {
  }

  virtual ~GetPartitionNamesPsResponse() noexcept;
  std::vector<std::string>  names;

  void __set_names(const std::vector<std::string> & val);

  bool operator == (const GetPartitionNamesPsResponse & rhs) const
  {
    if (!(names == rhs.names))
      return false;
    return true;
  }
  bool operator != (const GetPartitionNamesPsResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetPartitionNamesPsResponse & ) 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;
};

void swap(GetPartitionNamesPsResponse &a, GetPartitionNamesPsResponse &b);

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) {}
  bool catName :1;
  bool partVals :1;
  bool maxParts :1;
  bool userName :1;
  bool groupNames :1;
  bool validWriteIdList :1;
  bool id :1;
} _GetPartitionsPsWithAuthRequest__isset;

class GetPartitionsPsWithAuthRequest : public virtual ::apache::thrift::TBase {
 public:

  GetPartitionsPsWithAuthRequest(const GetPartitionsPsWithAuthRequest&);
  GetPartitionsPsWithAuthRequest& operator=(const GetPartitionsPsWithAuthRequest&);
  GetPartitionsPsWithAuthRequest() : catName(), dbName(), tblName(), maxParts(-1), userName(), validWriteIdList(), id(-1LL) {
  }

  virtual ~GetPartitionsPsWithAuthRequest() noexcept;
  std::string catName;
  std::string dbName;
  std::string tblName;
  std::vector<std::string>  partVals;
  int16_t maxParts;
  std::string userName;
  std::vector<std::string>  groupNames;
  std::string validWriteIdList;
  int64_t id;

  _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<std::string> & val);

  void __set_maxParts(const int16_t val);

  void __set_userName(const std::string& val);

  void __set_groupNames(const std::vector<std::string> & val);

  void __set_validWriteIdList(const std::string& val);

  void __set_id(const int64_t val);

  bool 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;
    return true;
  }
  bool operator != (const GetPartitionsPsWithAuthRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetPartitionsPsWithAuthRequest & ) 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;
};

void swap(GetPartitionsPsWithAuthRequest &a, GetPartitionsPsWithAuthRequest &b);

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() {
  }

  virtual ~GetPartitionsPsWithAuthResponse() noexcept;
  std::vector<Partition>  partitions;

  void __set_partitions(const std::vector<Partition> & val);

  bool operator == (const GetPartitionsPsWithAuthResponse & rhs) const
  {
    if (!(partitions == rhs.partitions))
      return false;
    return true;
  }
  bool operator != (const GetPartitionsPsWithAuthResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetPartitionsPsWithAuthResponse & ) 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;
};

void swap(GetPartitionsPsWithAuthResponse &a, GetPartitionsPsWithAuthResponse &b);

std::ostream& operator<<(std::ostream& out, const GetPartitionsPsWithAuthResponse& obj);

typedef struct _ReplicationMetrics__isset {
  _ReplicationMetrics__isset() : metadata(false), progress(false) {}
  bool metadata :1;
  bool progress :1;
} _ReplicationMetrics__isset;

class ReplicationMetrics : public virtual ::apache::thrift::TBase {
 public:

  ReplicationMetrics(const ReplicationMetrics&);
  ReplicationMetrics& operator=(const ReplicationMetrics&);
  ReplicationMetrics() : scheduledExecutionId(0), policy(), dumpExecutionId(0), metadata(), progress() {
  }

  virtual ~ReplicationMetrics() noexcept;
  int64_t scheduledExecutionId;
  std::string policy;
  int64_t dumpExecutionId;
  std::string metadata;
  std::string progress;

  _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);

  bool 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;
    return true;
  }
  bool operator != (const ReplicationMetrics &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ReplicationMetrics & ) 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;
};

void swap(ReplicationMetrics &a, ReplicationMetrics &b);

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() {
  }

  virtual ~ReplicationMetricList() noexcept;
  std::vector<ReplicationMetrics>  replicationMetricList;

  void __set_replicationMetricList(const std::vector<ReplicationMetrics> & val);

  bool operator == (const ReplicationMetricList & rhs) const
  {
    if (!(replicationMetricList == rhs.replicationMetricList))
      return false;
    return true;
  }
  bool operator != (const ReplicationMetricList &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ReplicationMetricList & ) 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;
};

void swap(ReplicationMetricList &a, ReplicationMetricList &b);

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() : scheduledExecutionId(0), policy(), dumpExecutionId(0) {
  }

  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
  {
    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;
  }
  bool operator != (const GetReplicationMetricsRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetReplicationMetricsRequest & ) 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;
};

void swap(GetReplicationMetricsRequest &a, GetReplicationMetricsRequest &b);

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() {
  }

  virtual ~GetOpenTxnsRequest() noexcept;
  std::vector<TxnType::type>  excludeTxnTypes;

  _GetOpenTxnsRequest__isset __isset;

  void __set_excludeTxnTypes(const std::vector<TxnType::type> & val);

  bool operator == (const GetOpenTxnsRequest & rhs) const
  {
    if (__isset.excludeTxnTypes != rhs.__isset.excludeTxnTypes)
      return false;
    else if (__isset.excludeTxnTypes && !(excludeTxnTypes == rhs.excludeTxnTypes))
      return false;
    return true;
  }
  bool operator != (const GetOpenTxnsRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GetOpenTxnsRequest & ) 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;
};

void swap(GetOpenTxnsRequest &a, GetOpenTxnsRequest &b);

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() : catName(), dbName(), procName() {
  }

  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
  {
    if (!(catName == rhs.catName))
      return false;
    if (!(dbName == rhs.dbName))
      return false;
    if (!(procName == rhs.procName))
      return false;
    return true;
  }
  bool operator != (const StoredProcedureRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const StoredProcedureRequest & ) 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;
};

void swap(StoredProcedureRequest &a, StoredProcedureRequest &b);

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() : catName(), dbName() {
  }

  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
  {
    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;
  }
  bool operator != (const ListStoredProcedureRequest &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ListStoredProcedureRequest & ) 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;
};

void swap(ListStoredProcedureRequest &a, ListStoredProcedureRequest &b);

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() : name(), dbName(), catName(), ownerName(), source() {
  }

  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
  {
    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;
  }
  bool operator != (const StoredProcedure &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const StoredProcedure & ) 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;
};

void swap(StoredProcedure &a, StoredProcedure &b);

std::ostream& operator<<(std::ostream& out, const StoredProcedure& 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() : message() {
  }

  virtual ~MetaException() noexcept;
  std::string message;

  _MetaException__isset __isset;

  void __set_message(const std::string& val);

  bool operator == (const MetaException & rhs) const
  {
    if (!(message == rhs.message))
      return false;
    return true;
  }
  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;
};

void swap(MetaException &a, MetaException &b);

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() : message() {
  }

  virtual ~UnknownTableException() noexcept;
  std::string message;

  _UnknownTableException__isset __isset;

  void __set_message(const std::string& val);

  bool operator == (const UnknownTableException & rhs) const
  {
    if (!(message == rhs.message))
      return false;
    return true;
  }
  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;
};

void swap(UnknownTableException &a, UnknownTableException &b);

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() : message() {
  }

  virtual ~UnknownDBException() noexcept;
  std::string message;

  _UnknownDBException__isset __isset;

  void __set_message(const std::string& val);

  bool operator == (const UnknownDBException & rhs) const
  {
    if (!(message == rhs.message))
      return false;
    return true;
  }
  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;
};

void swap(UnknownDBException &a, UnknownDBException &b);

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() : message() {
  }

  virtual ~AlreadyExistsException() noexcept;
  std::string message;

  _AlreadyExistsException__isset __isset;

  void __set_message(const std::string& val);

  bool operator == (const AlreadyExistsException & rhs) const
  {
    if (!(message == rhs.message))
      return false;
    return true;
  }
  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;
};

void swap(AlreadyExistsException &a, AlreadyExistsException &b);

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() : message() {
  }

  virtual ~InvalidPartitionException() noexcept;
  std::string message;

  _InvalidPartitionException__isset __isset;

  void __set_message(const std::string& val);

  bool operator == (const InvalidPartitionException & rhs) const
  {
    if (!(message == rhs.message))
      return false;
    return true;
  }
  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;
};

void swap(InvalidPartitionException &a, InvalidPartitionException &b);

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() : message() {
  }

  virtual ~UnknownPartitionException() noexcept;
  std::string message;

  _UnknownPartitionException__isset __isset;

  void __set_message(const std::string& val);

  bool operator == (const UnknownPartitionException & rhs) const
  {
    if (!(message == rhs.message))
      return false;
    return true;
  }
  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;
};

void swap(UnknownPartitionException &a, UnknownPartitionException &b);

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() : message() {
  }

  virtual ~InvalidObjectException() noexcept;
  std::string message;

  _InvalidObjectException__isset __isset;

  void __set_message(const std::string& val);

  bool operator == (const InvalidObjectException & rhs) const
  {
    if (!(message == rhs.message))
      return false;
    return true;
  }
  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;
};

void swap(InvalidObjectException &a, InvalidObjectException &b);

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() : message() {
  }

  virtual ~NoSuchObjectException() noexcept;
  std::string message;

  _NoSuchObjectException__isset __isset;

  void __set_message(const std::string& val);

  bool operator == (const NoSuchObjectException & rhs) const
  {
    if (!(message == rhs.message))
      return false;
    return true;
  }
  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;
};

void swap(NoSuchObjectException &a, NoSuchObjectException &b);

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() : message() {
  }

  virtual ~InvalidOperationException() noexcept;
  std::string message;

  _InvalidOperationException__isset __isset;

  void __set_message(const std::string& val);

  bool operator == (const InvalidOperationException & rhs) const
  {
    if (!(message == rhs.message))
      return false;
    return true;
  }
  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;
};

void swap(InvalidOperationException &a, InvalidOperationException &b);

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() : message() {
  }

  virtual ~ConfigValSecurityException() noexcept;
  std::string message;

  _ConfigValSecurityException__isset __isset;

  void __set_message(const std::string& val);

  bool operator == (const ConfigValSecurityException & rhs) const
  {
    if (!(message == rhs.message))
      return false;
    return true;
  }
  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;
};

void swap(ConfigValSecurityException &a, ConfigValSecurityException &b);

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() : message() {
  }

  virtual ~InvalidInputException() noexcept;
  std::string message;

  _InvalidInputException__isset __isset;

  void __set_message(const std::string& val);

  bool operator == (const InvalidInputException & rhs) const
  {
    if (!(message == rhs.message))
      return false;
    return true;
  }
  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;
};

void swap(InvalidInputException &a, InvalidInputException &b);

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() : message() {
  }

  virtual ~NoSuchTxnException() noexcept;
  std::string message;

  _NoSuchTxnException__isset __isset;

  void __set_message(const std::string& val);

  bool operator == (const NoSuchTxnException & rhs) const
  {
    if (!(message == rhs.message))
      return false;
    return true;
  }
  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;
};

void swap(NoSuchTxnException &a, NoSuchTxnException &b);

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() : message() {
  }

  virtual ~TxnAbortedException() noexcept;
  std::string message;

  _TxnAbortedException__isset __isset;

  void __set_message(const std::string& val);

  bool operator == (const TxnAbortedException & rhs) const
  {
    if (!(message == rhs.message))
      return false;
    return true;
  }
  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;
};

void swap(TxnAbortedException &a, TxnAbortedException &b);

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() : message() {
  }

  virtual ~TxnOpenException() noexcept;
  std::string message;

  _TxnOpenException__isset __isset;

  void __set_message(const std::string& val);

  bool operator == (const TxnOpenException & rhs) const
  {
    if (!(message == rhs.message))
      return false;
    return true;
  }
  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;
};

void swap(TxnOpenException &a, TxnOpenException &b);

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() : message() {
  }

  virtual ~NoSuchLockException() noexcept;
  std::string message;

  _NoSuchLockException__isset __isset;

  void __set_message(const std::string& val);

  bool operator == (const NoSuchLockException & rhs) const
  {
    if (!(message == rhs.message))
      return false;
    return true;
  }
  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;
};

void swap(NoSuchLockException &a, NoSuchLockException &b);

std::ostream& operator<<(std::ostream& out, const NoSuchLockException& obj);

}}} // namespace

#endif