You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by we...@apache.org on 2017/09/07 05:58:57 UTC
[43/50] [abbrv] hive git commit: HIVE-14671 : merge master into
hive-14535 (Wei Zheng)
http://git-wip-us.apache.org/repos/asf/hive/blob/42a38577/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
----------------------------------------------------------------------
diff --cc standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
index 0000000,d5963f3..cfbc488
mode 000000,100644..100644
--- a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
+++ b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
@@@ -1,0 -1,9033 +1,9034 @@@
+ /**
+ * Autogenerated by Thrift Compiler (0.9.3)
+ *
+ * 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/protocol/TProtocol.h>
+ #include <thrift/transport/TTransport.h>
+
+ #include <thrift/cxxfunctional.h>
+ #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;
+
+ struct PrincipalType {
+ enum type {
+ USER = 1,
+ ROLE = 2,
+ GROUP = 3
+ };
+ };
+
+ extern const std::map<int, const char*> _PrincipalType_VALUES_TO_NAMES;
+
+ struct PartitionEventType {
+ enum type {
+ LOAD_DONE = 1
+ };
+ };
+
+ extern const std::map<int, const char*> _PartitionEventType_VALUES_TO_NAMES;
+
+ struct TxnState {
+ enum type {
+ COMMITTED = 1,
+ ABORTED = 2,
+ OPEN = 3
+ };
+ };
+
+ extern const std::map<int, const char*> _TxnState_VALUES_TO_NAMES;
+
+ struct LockLevel {
+ enum type {
+ DB = 1,
+ TABLE = 2,
+ PARTITION = 3
+ };
+ };
+
+ extern const std::map<int, const char*> _LockLevel_VALUES_TO_NAMES;
+
+ struct LockState {
+ enum type {
+ ACQUIRED = 1,
+ WAITING = 2,
+ ABORT = 3,
+ NOT_ACQUIRED = 4
+ };
+ };
+
+ extern const std::map<int, const char*> _LockState_VALUES_TO_NAMES;
+
+ struct LockType {
+ enum type {
+ SHARED_READ = 1,
+ SHARED_WRITE = 2,
+ EXCLUSIVE = 3
+ };
+ };
+
+ extern const std::map<int, const char*> _LockType_VALUES_TO_NAMES;
+
+ struct CompactionType {
+ enum type {
+ MINOR = 1,
+ MAJOR = 2
+ };
+ };
+
+ extern const std::map<int, const char*> _CompactionType_VALUES_TO_NAMES;
+
+ struct GrantRevokeType {
+ enum type {
+ GRANT = 1,
+ REVOKE = 2
+ };
+ };
+
+ extern const std::map<int, const char*> _GrantRevokeType_VALUES_TO_NAMES;
+
+ 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;
+
+ struct EventRequestType {
+ enum type {
+ INSERT = 1,
+ UPDATE = 2,
+ DELETE = 3
+ };
+ };
+
+ extern const std::map<int, const char*> _EventRequestType_VALUES_TO_NAMES;
+
+ struct FunctionType {
+ enum type {
+ JAVA = 1
+ };
+ };
+
+ extern const std::map<int, const char*> _FunctionType_VALUES_TO_NAMES;
+
+ struct ResourceType {
+ enum type {
+ JAR = 1,
+ FILE = 2,
+ ARCHIVE = 3
+ };
+ };
+
+ extern const std::map<int, const char*> _ResourceType_VALUES_TO_NAMES;
+
+ struct FileMetadataExprType {
+ enum type {
+ ORC_SARG = 1
+ };
+ };
+
+ extern const std::map<int, const char*> _FileMetadataExprType_VALUES_TO_NAMES;
+
+ struct ClientCapability {
+ enum type {
- TEST_CAPABILITY = 1
++ TEST_CAPABILITY = 1,
++ INSERT_ONLY_TABLES = 2
+ };
+ };
+
+ extern const std::map<int, const char*> _ClientCapability_VALUES_TO_NAMES;
+
+ class Version;
+
+ class FieldSchema;
+
+ class SQLPrimaryKey;
+
+ class SQLForeignKey;
+
+ class SQLUniqueConstraint;
+
+ class SQLNotNullConstraint;
+
+ class Type;
+
+ class HiveObjectRef;
+
+ class PrivilegeGrantInfo;
+
+ class HiveObjectPrivilege;
+
+ class PrivilegeBag;
+
+ class PrincipalPrivilegeSet;
+
+ class GrantRevokePrivilegeRequest;
+
+ class GrantRevokePrivilegeResponse;
+
+ class Role;
+
+ class RolePrincipalGrant;
+
+ class GetRoleGrantsForPrincipalRequest;
+
+ class GetRoleGrantsForPrincipalResponse;
+
+ class GetPrincipalsInRoleRequest;
+
+ class GetPrincipalsInRoleResponse;
+
+ class GrantRevokeRoleRequest;
+
+ class GrantRevokeRoleResponse;
+
+ class Database;
+
+ class SerDeInfo;
+
+ class Order;
+
+ class SkewedInfo;
+
+ class StorageDescriptor;
+
+ class Table;
+
+ class Partition;
+
+ class PartitionWithoutSD;
+
+ class PartitionSpecWithSharedSD;
+
+ class PartitionListComposingSpec;
+
+ class PartitionSpec;
+
+ class Index;
+
+ class BooleanColumnStatsData;
+
+ class DoubleColumnStatsData;
+
+ class LongColumnStatsData;
+
+ class StringColumnStatsData;
+
+ class BinaryColumnStatsData;
+
+ class Decimal;
+
+ class DecimalColumnStatsData;
+
+ class Date;
+
+ class DateColumnStatsData;
+
+ class ColumnStatisticsData;
+
+ class ColumnStatisticsObj;
+
+ class ColumnStatisticsDesc;
+
+ class ColumnStatistics;
+
+ class AggrStats;
+
+ class SetPartitionsStatsRequest;
+
+ class Schema;
+
+ class EnvironmentContext;
+
+ class PrimaryKeysRequest;
+
+ class PrimaryKeysResponse;
+
+ class ForeignKeysRequest;
+
+ class ForeignKeysResponse;
+
+ class UniqueConstraintsRequest;
+
+ class UniqueConstraintsResponse;
+
+ class NotNullConstraintsRequest;
+
+ class NotNullConstraintsResponse;
+
+ class DropConstraintRequest;
+
+ class AddPrimaryKeyRequest;
+
+ class AddForeignKeyRequest;
+
+ class AddUniqueConstraintRequest;
+
+ class AddNotNullConstraintRequest;
+
+ class PartitionsByExprResult;
+
+ class PartitionsByExprRequest;
+
+ class TableStatsResult;
+
+ class PartitionsStatsResult;
+
+ class TableStatsRequest;
+
+ class PartitionsStatsRequest;
+
+ class AddPartitionsResult;
+
+ class AddPartitionsRequest;
+
+ class DropPartitionsResult;
+
+ class DropPartitionsExpr;
+
+ class RequestPartsSpec;
+
+ class DropPartitionsRequest;
+
+ class ResourceUri;
+
+ class Function;
+
+ class TxnInfo;
+
+ class GetOpenTxnsInfoResponse;
+
+ class GetOpenTxnsResponse;
+
+ class OpenTxnRequest;
+
+ class OpenTxnsResponse;
+
+ class AbortTxnRequest;
+
+ class AbortTxnsRequest;
+
+ class CommitTxnRequest;
+
+ 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 CompactionResponse;
+
+ class ShowCompactRequest;
+
+ class ShowCompactResponseElement;
+
+ class ShowCompactResponse;
+
+ class AddDynamicPartitions;
+
+ class NotificationEventRequest;
+
+ class NotificationEvent;
+
+ class NotificationEventResponse;
+
+ class CurrentNotificationEventId;
+
+ class NotificationEventsCountRequest;
+
+ class NotificationEventsCountResponse;
+
+ class InsertEventRequestData;
+
+ class FireEventRequestData;
+
+ class FireEventRequest;
+
+ class FireEventResponse;
+
+ 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 GetTableRequest;
+
+ class GetTableResult;
+
+ class GetTablesRequest;
+
+ class GetTablesResult;
+
+ class CmRecycleRequest;
+
+ class CmRecycleResponse;
+
+ class TableMeta;
+
+ class MetaException;
+
+ class UnknownTableException;
+
+ class UnknownDBException;
+
+ class AlreadyExistsException;
+
+ class InvalidPartitionException;
+
+ class UnknownPartitionException;
+
+ class InvalidObjectException;
+
+ class NoSuchObjectException;
+
+ class IndexAlreadyExistsException;
+
+ 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:
+
+ Version(const Version&);
+ Version& operator=(const Version&);
+ Version() : version(), comments() {
+ }
+
+ virtual ~Version() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const Version& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ 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:
+
+ FieldSchema(const FieldSchema&);
+ FieldSchema& operator=(const FieldSchema&);
+ FieldSchema() : name(), type(), comment() {
+ }
+
+ virtual ~FieldSchema() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const FieldSchema& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ 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) {}
+ 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;
+ } _SQLPrimaryKey__isset;
+
+ class SQLPrimaryKey {
+ 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) {
+ }
+
+ virtual ~SQLPrimaryKey() throw();
+ 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;
+
+ _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);
+
+ 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;
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const SQLPrimaryKey& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ 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) {}
+ 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;
+ } _SQLForeignKey__isset;
+
+ class SQLForeignKey {
+ 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) {
+ }
+
+ virtual ~SQLForeignKey() throw();
+ 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;
+
+ _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);
+
+ 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;
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const SQLForeignKey& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ typedef struct _SQLUniqueConstraint__isset {
+ _SQLUniqueConstraint__isset() : 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 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:
+
+ SQLUniqueConstraint(const SQLUniqueConstraint&);
+ SQLUniqueConstraint& operator=(const SQLUniqueConstraint&);
+ SQLUniqueConstraint() : table_db(), table_name(), column_name(), key_seq(0), uk_name(), enable_cstr(0), validate_cstr(0), rely_cstr(0) {
+ }
+
+ virtual ~SQLUniqueConstraint() throw();
+ 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_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 (!(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);
+
+ inline std::ostream& operator<<(std::ostream& out, const SQLUniqueConstraint& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ typedef struct _SQLNotNullConstraint__isset {
+ _SQLNotNullConstraint__isset() : table_db(false), table_name(false), column_name(false), nn_name(false), enable_cstr(false), validate_cstr(false), rely_cstr(false) {}
+ 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:
+
+ SQLNotNullConstraint(const SQLNotNullConstraint&);
+ SQLNotNullConstraint& operator=(const SQLNotNullConstraint&);
+ SQLNotNullConstraint() : table_db(), table_name(), column_name(), nn_name(), enable_cstr(0), validate_cstr(0), rely_cstr(0) {
+ }
+
+ virtual ~SQLNotNullConstraint() throw();
+ 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_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 (!(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);
+
+ inline std::ostream& operator<<(std::ostream& out, const SQLNotNullConstraint& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ 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:
+
+ Type(const Type&);
+ Type& operator=(const Type&);
+ Type() : name(), type1(), type2() {
+ }
+
+ virtual ~Type() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const Type& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ typedef struct _HiveObjectRef__isset {
+ _HiveObjectRef__isset() : objectType(false), dbName(false), objectName(false), partValues(false), columnName(false) {}
+ bool objectType :1;
+ bool dbName :1;
+ bool objectName :1;
+ bool partValues :1;
+ bool columnName :1;
+ } _HiveObjectRef__isset;
+
+ class HiveObjectRef {
+ public:
+
+ HiveObjectRef(const HiveObjectRef&);
+ HiveObjectRef& operator=(const HiveObjectRef&);
+ HiveObjectRef() : objectType((HiveObjectType::type)0), dbName(), objectName(), columnName() {
+ }
+
+ virtual ~HiveObjectRef() throw();
+ HiveObjectType::type objectType;
+ std::string dbName;
+ std::string objectName;
+ std::vector<std::string> partValues;
+ std::string columnName;
+
+ _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);
+
+ 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;
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const HiveObjectRef& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ 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:
+
+ PrivilegeGrantInfo(const PrivilegeGrantInfo&);
+ PrivilegeGrantInfo& operator=(const PrivilegeGrantInfo&);
+ PrivilegeGrantInfo() : privilege(), createTime(0), grantor(), grantorType((PrincipalType::type)0), grantOption(0) {
+ }
+
+ virtual ~PrivilegeGrantInfo() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const PrivilegeGrantInfo& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ typedef struct _HiveObjectPrivilege__isset {
+ _HiveObjectPrivilege__isset() : hiveObject(false), principalName(false), principalType(false), grantInfo(false) {}
+ bool hiveObject :1;
+ bool principalName :1;
+ bool principalType :1;
+ bool grantInfo :1;
+ } _HiveObjectPrivilege__isset;
+
+ class HiveObjectPrivilege {
+ public:
+
+ HiveObjectPrivilege(const HiveObjectPrivilege&);
+ HiveObjectPrivilege& operator=(const HiveObjectPrivilege&);
+ HiveObjectPrivilege() : principalName(), principalType((PrincipalType::type)0) {
+ }
+
+ virtual ~HiveObjectPrivilege() throw();
+ HiveObjectRef hiveObject;
+ std::string principalName;
+ PrincipalType::type principalType;
+ PrivilegeGrantInfo grantInfo;
+
+ _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);
+
+ 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;
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const HiveObjectPrivilege& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ typedef struct _PrivilegeBag__isset {
+ _PrivilegeBag__isset() : privileges(false) {}
+ bool privileges :1;
+ } _PrivilegeBag__isset;
+
+ class PrivilegeBag {
+ public:
+
+ PrivilegeBag(const PrivilegeBag&);
+ PrivilegeBag& operator=(const PrivilegeBag&);
+ PrivilegeBag() {
+ }
+
+ virtual ~PrivilegeBag() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const PrivilegeBag& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ 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:
+
+ PrincipalPrivilegeSet(const PrincipalPrivilegeSet&);
+ PrincipalPrivilegeSet& operator=(const PrincipalPrivilegeSet&);
+ PrincipalPrivilegeSet() {
+ }
+
+ virtual ~PrincipalPrivilegeSet() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const PrincipalPrivilegeSet& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ 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:
+
+ GrantRevokePrivilegeRequest(const GrantRevokePrivilegeRequest&);
+ GrantRevokePrivilegeRequest& operator=(const GrantRevokePrivilegeRequest&);
+ GrantRevokePrivilegeRequest() : requestType((GrantRevokeType::type)0), revokeGrantOption(0) {
+ }
+
+ virtual ~GrantRevokePrivilegeRequest() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const GrantRevokePrivilegeRequest& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ typedef struct _GrantRevokePrivilegeResponse__isset {
+ _GrantRevokePrivilegeResponse__isset() : success(false) {}
+ bool success :1;
+ } _GrantRevokePrivilegeResponse__isset;
+
+ class GrantRevokePrivilegeResponse {
+ public:
+
+ GrantRevokePrivilegeResponse(const GrantRevokePrivilegeResponse&);
+ GrantRevokePrivilegeResponse& operator=(const GrantRevokePrivilegeResponse&);
+ GrantRevokePrivilegeResponse() : success(0) {
+ }
+
+ virtual ~GrantRevokePrivilegeResponse() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const GrantRevokePrivilegeResponse& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ 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:
+
+ Role(const Role&);
+ Role& operator=(const Role&);
+ Role() : roleName(), createTime(0), ownerName() {
+ }
+
+ virtual ~Role() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const Role& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ 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:
+
+ 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() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const RolePrincipalGrant& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+
+ class GetRoleGrantsForPrincipalRequest {
+ public:
+
+ GetRoleGrantsForPrincipalRequest(const GetRoleGrantsForPrincipalRequest&);
+ GetRoleGrantsForPrincipalRequest& operator=(const GetRoleGrantsForPrincipalRequest&);
+ GetRoleGrantsForPrincipalRequest() : principal_name(), principal_type((PrincipalType::type)0) {
+ }
+
+ virtual ~GetRoleGrantsForPrincipalRequest() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const GetRoleGrantsForPrincipalRequest& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+
+ class GetRoleGrantsForPrincipalResponse {
+ public:
+
+ GetRoleGrantsForPrincipalResponse(const GetRoleGrantsForPrincipalResponse&);
+ GetRoleGrantsForPrincipalResponse& operator=(const GetRoleGrantsForPrincipalResponse&);
+ GetRoleGrantsForPrincipalResponse() {
+ }
+
+ virtual ~GetRoleGrantsForPrincipalResponse() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const GetRoleGrantsForPrincipalResponse& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+
+ class GetPrincipalsInRoleRequest {
+ public:
+
+ GetPrincipalsInRoleRequest(const GetPrincipalsInRoleRequest&);
+ GetPrincipalsInRoleRequest& operator=(const GetPrincipalsInRoleRequest&);
+ GetPrincipalsInRoleRequest() : roleName() {
+ }
+
+ virtual ~GetPrincipalsInRoleRequest() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const GetPrincipalsInRoleRequest& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+
+ class GetPrincipalsInRoleResponse {
+ public:
+
+ GetPrincipalsInRoleResponse(const GetPrincipalsInRoleResponse&);
+ GetPrincipalsInRoleResponse& operator=(const GetPrincipalsInRoleResponse&);
+ GetPrincipalsInRoleResponse() {
+ }
+
+ virtual ~GetPrincipalsInRoleResponse() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const GetPrincipalsInRoleResponse& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ 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:
+
+ 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() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const GrantRevokeRoleRequest& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ typedef struct _GrantRevokeRoleResponse__isset {
+ _GrantRevokeRoleResponse__isset() : success(false) {}
+ bool success :1;
+ } _GrantRevokeRoleResponse__isset;
+
+ class GrantRevokeRoleResponse {
+ public:
+
+ GrantRevokeRoleResponse(const GrantRevokeRoleResponse&);
+ GrantRevokeRoleResponse& operator=(const GrantRevokeRoleResponse&);
+ GrantRevokeRoleResponse() : success(0) {
+ }
+
+ virtual ~GrantRevokeRoleResponse() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const GrantRevokeRoleResponse& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ typedef struct _Database__isset {
+ _Database__isset() : name(false), description(false), locationUri(false), parameters(false), privileges(false), ownerName(false), ownerType(false) {}
+ bool name :1;
+ bool description :1;
+ bool locationUri :1;
+ bool parameters :1;
+ bool privileges :1;
+ bool ownerName :1;
+ bool ownerType :1;
+ } _Database__isset;
+
+ class Database {
+ public:
+
+ Database(const Database&);
+ Database& operator=(const Database&);
+ Database() : name(), description(), locationUri(), ownerName(), ownerType((PrincipalType::type)0) {
+ }
+
+ virtual ~Database() throw();
+ std::string name;
+ std::string description;
+ std::string locationUri;
+ std::map<std::string, std::string> parameters;
+ PrincipalPrivilegeSet privileges;
+ std::string ownerName;
+ PrincipalType::type ownerType;
+
+ _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);
+
+ 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;
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const Database& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ typedef struct _SerDeInfo__isset {
+ _SerDeInfo__isset() : name(false), serializationLib(false), parameters(false) {}
+ bool name :1;
+ bool serializationLib :1;
+ bool parameters :1;
+ } _SerDeInfo__isset;
+
+ class SerDeInfo {
+ public:
+
+ SerDeInfo(const SerDeInfo&);
+ SerDeInfo& operator=(const SerDeInfo&);
+ SerDeInfo() : name(), serializationLib() {
+ }
+
+ virtual ~SerDeInfo() throw();
+ std::string name;
+ std::string serializationLib;
+ std::map<std::string, std::string> parameters;
+
+ _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);
+
+ bool operator == (const SerDeInfo & rhs) const
+ {
+ if (!(name == rhs.name))
+ return false;
+ if (!(serializationLib == rhs.serializationLib))
+ return false;
+ if (!(parameters == rhs.parameters))
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const SerDeInfo& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ typedef struct _Order__isset {
+ _Order__isset() : col(false), order(false) {}
+ bool col :1;
+ bool order :1;
+ } _Order__isset;
+
+ class Order {
+ public:
+
+ Order(const Order&);
+ Order& operator=(const Order&);
+ Order() : col(), order(0) {
+ }
+
+ virtual ~Order() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const Order& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ 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:
+
+ SkewedInfo(const SkewedInfo&);
+ SkewedInfo& operator=(const SkewedInfo&);
+ SkewedInfo() {
+ }
+
+ virtual ~SkewedInfo() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const SkewedInfo& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ 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:
+
+ StorageDescriptor(const StorageDescriptor&);
+ StorageDescriptor& operator=(const StorageDescriptor&);
+ StorageDescriptor() : location(), inputFormat(), outputFormat(), compressed(0), numBuckets(0), storedAsSubDirectories(0) {
+ }
+
+ virtual ~StorageDescriptor() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const StorageDescriptor& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ 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) {}
+ 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;
+ } _Table__isset;
+
+ class Table {
+ 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) {
+ }
+
+ virtual ~Table() throw();
+ 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;
+
+ _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);
+
+ 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;
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const Table& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ typedef struct _Partition__isset {
+ _Partition__isset() : values(false), dbName(false), tableName(false), createTime(false), lastAccessTime(false), sd(false), parameters(false), privileges(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;
+ } _Partition__isset;
+
+ class Partition {
+ public:
+
+ Partition(const Partition&);
+ Partition& operator=(const Partition&);
+ Partition() : dbName(), tableName(), createTime(0), lastAccessTime(0) {
+ }
+
+ virtual ~Partition() throw();
+ 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;
+
+ _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);
+
+ 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;
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const Partition& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ 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:
+
+ PartitionWithoutSD(const PartitionWithoutSD&);
+ PartitionWithoutSD& operator=(const PartitionWithoutSD&);
+ PartitionWithoutSD() : createTime(0), lastAccessTime(0), relativePath() {
+ }
+
+ virtual ~PartitionWithoutSD() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const PartitionWithoutSD& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ typedef struct _PartitionSpecWithSharedSD__isset {
+ _PartitionSpecWithSharedSD__isset() : partitions(false), sd(false) {}
+ bool partitions :1;
+ bool sd :1;
+ } _PartitionSpecWithSharedSD__isset;
+
+ class PartitionSpecWithSharedSD {
+ public:
+
+ PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD&);
+ PartitionSpecWithSharedSD& operator=(const PartitionSpecWithSharedSD&);
+ PartitionSpecWithSharedSD() {
+ }
+
+ virtual ~PartitionSpecWithSharedSD() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const PartitionSpecWithSharedSD& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ typedef struct _PartitionListComposingSpec__isset {
+ _PartitionListComposingSpec__isset() : partitions(false) {}
+ bool partitions :1;
+ } _PartitionListComposingSpec__isset;
+
+ class PartitionListComposingSpec {
+ public:
+
+ PartitionListComposingSpec(const PartitionListComposingSpec&);
+ PartitionListComposingSpec& operator=(const PartitionListComposingSpec&);
+ PartitionListComposingSpec() {
+ }
+
+ virtual ~PartitionListComposingSpec() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const PartitionListComposingSpec& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ typedef struct _PartitionSpec__isset {
+ _PartitionSpec__isset() : dbName(false), tableName(false), rootPath(false), sharedSDPartitionSpec(false), partitionList(false) {}
+ bool dbName :1;
+ bool tableName :1;
+ bool rootPath :1;
+ bool sharedSDPartitionSpec :1;
+ bool partitionList :1;
+ } _PartitionSpec__isset;
+
+ class PartitionSpec {
+ public:
+
+ PartitionSpec(const PartitionSpec&);
+ PartitionSpec& operator=(const PartitionSpec&);
+ PartitionSpec() : dbName(), tableName(), rootPath() {
+ }
+
+ virtual ~PartitionSpec() throw();
+ std::string dbName;
+ std::string tableName;
+ std::string rootPath;
+ PartitionSpecWithSharedSD sharedSDPartitionSpec;
+ PartitionListComposingSpec partitionList;
+
+ _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);
+
+ 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;
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const PartitionSpec& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ typedef struct _Index__isset {
+ _Index__isset() : indexName(false), indexHandlerClass(false), dbName(false), origTableName(false), createTime(false), lastAccessTime(false), indexTableName(false), sd(false), parameters(false), deferredRebuild(false) {}
+ bool indexName :1;
+ bool indexHandlerClass :1;
+ bool dbName :1;
+ bool origTableName :1;
+ bool createTime :1;
+ bool lastAccessTime :1;
+ bool indexTableName :1;
+ bool sd :1;
+ bool parameters :1;
+ bool deferredRebuild :1;
+ } _Index__isset;
+
+ class Index {
+ public:
+
+ Index(const Index&);
+ Index& operator=(const Index&);
+ Index() : indexName(), indexHandlerClass(), dbName(), origTableName(), createTime(0), lastAccessTime(0), indexTableName(), deferredRebuild(0) {
+ }
+
+ virtual ~Index() throw();
+ std::string indexName;
+ std::string indexHandlerClass;
+ std::string dbName;
+ std::string origTableName;
+ int32_t createTime;
+ int32_t lastAccessTime;
+ std::string indexTableName;
+ StorageDescriptor sd;
+ std::map<std::string, std::string> parameters;
+ bool deferredRebuild;
+
+ _Index__isset __isset;
+
+ void __set_indexName(const std::string& val);
+
+ void __set_indexHandlerClass(const std::string& val);
+
+ void __set_dbName(const std::string& val);
+
+ void __set_origTableName(const std::string& val);
+
+ void __set_createTime(const int32_t val);
+
+ void __set_lastAccessTime(const int32_t val);
+
+ void __set_indexTableName(const std::string& val);
+
+ void __set_sd(const StorageDescriptor& val);
+
+ void __set_parameters(const std::map<std::string, std::string> & val);
+
+ void __set_deferredRebuild(const bool val);
+
+ bool operator == (const Index & rhs) const
+ {
+ if (!(indexName == rhs.indexName))
+ return false;
+ if (!(indexHandlerClass == rhs.indexHandlerClass))
+ return false;
+ if (!(dbName == rhs.dbName))
+ return false;
+ if (!(origTableName == rhs.origTableName))
+ return false;
+ if (!(createTime == rhs.createTime))
+ return false;
+ if (!(lastAccessTime == rhs.lastAccessTime))
+ return false;
+ if (!(indexTableName == rhs.indexTableName))
+ return false;
+ if (!(sd == rhs.sd))
+ return false;
+ if (!(parameters == rhs.parameters))
+ return false;
+ if (!(deferredRebuild == rhs.deferredRebuild))
+ return false;
+ return true;
+ }
+ bool operator != (const Index &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Index & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+ virtual void printTo(std::ostream& out) const;
+ };
+
+ void swap(Index &a, Index &b);
+
+ inline std::ostream& operator<<(std::ostream& out, const Index& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ typedef struct _BooleanColumnStatsData__isset {
+ _BooleanColumnStatsData__isset() : bitVectors(false) {}
+ bool bitVectors :1;
+ } _BooleanColumnStatsData__isset;
+
+ class BooleanColumnStatsData {
+ public:
+
+ BooleanColumnStatsData(const BooleanColumnStatsData&);
+ BooleanColumnStatsData& operator=(const BooleanColumnStatsData&);
+ BooleanColumnStatsData() : numTrues(0), numFalses(0), numNulls(0), bitVectors() {
+ }
+
+ virtual ~BooleanColumnStatsData() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const BooleanColumnStatsData& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ 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:
+
+ DoubleColumnStatsData(const DoubleColumnStatsData&);
+ DoubleColumnStatsData& operator=(const DoubleColumnStatsData&);
+ DoubleColumnStatsData() : lowValue(0), highValue(0), numNulls(0), numDVs(0), bitVectors() {
+ }
+
+ virtual ~DoubleColumnStatsData() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const DoubleColumnStatsData& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ 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:
+
+ LongColumnStatsData(const LongColumnStatsData&);
+ LongColumnStatsData& operator=(const LongColumnStatsData&);
+ LongColumnStatsData() : lowValue(0), highValue(0), numNulls(0), numDVs(0), bitVectors() {
+ }
+
+ virtual ~LongColumnStatsData() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const LongColumnStatsData& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ typedef struct _StringColumnStatsData__isset {
+ _StringColumnStatsData__isset() : bitVectors(false) {}
+ bool bitVectors :1;
+ } _StringColumnStatsData__isset;
+
+ class StringColumnStatsData {
+ public:
+
+ StringColumnStatsData(const StringColumnStatsData&);
+ StringColumnStatsData& operator=(const StringColumnStatsData&);
+ StringColumnStatsData() : maxColLen(0), avgColLen(0), numNulls(0), numDVs(0), bitVectors() {
+ }
+
+ virtual ~StringColumnStatsData() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const StringColumnStatsData& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+ typedef struct _BinaryColumnStatsData__isset {
+ _BinaryColumnStatsData__isset() : bitVectors(false) {}
+ bool bitVectors :1;
+ } _BinaryColumnStatsData__isset;
+
+ class BinaryColumnStatsData {
+ public:
+
+ BinaryColumnStatsData(const BinaryColumnStatsData&);
+ BinaryColumnStatsData& operator=(const BinaryColumnStatsData&);
+ BinaryColumnStatsData() : maxColLen(0), avgColLen(0), numNulls(0), bitVectors() {
+ }
+
+ virtual ~BinaryColumnStatsData() throw();
+ 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);
+
+ inline std::ostream& operator<<(std::ostream& out, const BinaryColumnStatsData& obj)
+ {
+ obj.printTo(out);
+ return out;
+ }
+
+
+ class Decimal {
+ public:
+
+ Decimal(const Decimal&);
+ Decimal& operator=(const Decimal&);
+ Decimal() : unscaled(), scale(0) {
+ }
+
+ virtual ~Decimal() throw();
+ std::string unscaled;
+ int16_t scale;
+
+ void __set_unscaled(const std::string& val);
+
+ void __set_scale(const int16_t val);
+
+ bool operator == (const Decimal & rhs) const
+ {
+ if (!(unscaled == rhs.unscaled))
+ return false;
+ if (!(scale =
<TRUNCATED>