[45/91] [abbrv] [partial] hive git commit: HIVE-20097 : Convert standalone-metastore to a submodule (Alexander Kolbasov reviewed by Vihang Karajgaonkar)

[sershe]

http://git-wip-us.apache.org/repos/asf/hive/blob/20eb7b51/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_types.h
----------------------------------------------------------------------
diff --git 
a/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_types.h
 
b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_types.h
new file mode 100644
index 0000000..f5913fc
--- /dev/null
+++ 
b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_types.h
@@ -0,0 +1,14125 @@
+/**
+ * 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 SerdeType {
+  enum type {
+    HIVE = 1,
+    SCHEMA_REGISTRY = 2
+  };
+};
+
+extern const std::map<int, const char*> _SerdeType_VALUES_TO_NAMES;
+
+struct SchemaType {
+  enum type {
+    HIVE = 1,
+    AVRO = 2
+  };
+};
+
+extern const std::map<int, const char*> _SchemaType_VALUES_TO_NAMES;
+
+struct SchemaCompatibility {
+  enum type {
+    NONE = 1,
+    BACKWARD = 2,
+    FORWARD = 3,
+    BOTH = 4
+  };
+};
+
+extern const std::map<int, const char*> _SchemaCompatibility_VALUES_TO_NAMES;
+
+struct SchemaValidation {
+  enum type {
+    LATEST = 1,
+    ALL = 2
+  };
+};
+
+extern const std::map<int, const char*> _SchemaValidation_VALUES_TO_NAMES;
+
+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;
+
+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,
+    INSERT_ONLY_TABLES = 2
+  };
+};
+
+extern const std::map<int, const char*> _ClientCapability_VALUES_TO_NAMES;
+
+struct WMResourcePlanStatus {
+  enum type {
+    ACTIVE = 1,
+    ENABLED = 2,
+    DISABLED = 3
+  };
+};
+
+extern const std::map<int, const char*> _WMResourcePlanStatus_VALUES_TO_NAMES;
+
+struct WMPoolSchedulingPolicy {
+  enum type {
+    FAIR = 1,
+    FIFO = 2
+  };
+};
+
+extern const std::map<int, const char*> 
_WMPoolSchedulingPolicy_VALUES_TO_NAMES;
+
+class Version;
+
+class FieldSchema;
+
+class SQLPrimaryKey;
+
+class SQLForeignKey;
+
+class SQLUniqueConstraint;
+
+class SQLNotNullConstraint;
+
+class SQLDefaultConstraint;
+
+class SQLCheckConstraint;
+
+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 Catalog;
+
+class CreateCatalogRequest;
+
+class AlterCatalogRequest;
+
+class GetCatalogRequest;
+
+class GetCatalogResponse;
+
+class GetCatalogsResponse;
+
+class DropCatalogRequest;
+
+class Database;
+
+class SerDeInfo;
+
+class Order;
+
+class SkewedInfo;
+
+class StorageDescriptor;
+
+class Table;
+
+class Partition;
+
+class PartitionWithoutSD;
+
+class PartitionSpecWithSharedSD;
+
+class PartitionListComposingSpec;
+
+class PartitionSpec;
+
+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 DefaultConstraintsRequest;
+
+class DefaultConstraintsResponse;
+
+class CheckConstraintsRequest;
+
+class CheckConstraintsResponse;
+
+class DropConstraintRequest;
+
+class AddPrimaryKeyRequest;
+
+class AddForeignKeyRequest;
+
+class AddUniqueConstraintRequest;
+
+class AddNotNullConstraintRequest;
+
+class AddDefaultConstraintRequest;
+
+class AddCheckConstraintRequest;
+
+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 PartitionValuesRequest;
+
+class PartitionValuesRow;
+
+class PartitionValuesResponse;
+
+class ResourceUri;
+
+class Function;
+
+class TxnInfo;
+
+class GetOpenTxnsInfoResponse;
+
+class GetOpenTxnsResponse;
+
+class OpenTxnRequest;
+
+class OpenTxnsResponse;
+
+class AbortTxnRequest;
+
+class AbortTxnsRequest;
+
+class CommitTxnRequest;
+
+class WriteEventInfo;
+
+class ReplTblWriteIdStateRequest;
+
+class GetValidWriteIdsRequest;
+
+class TableValidWriteIds;
+
+class GetValidWriteIdsResponse;
+
+class AllocateTableWriteIdsRequest;
+
+class TxnToWriteId;
+
+class AllocateTableWriteIdsResponse;
+
+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 BasicTxnInfo;
+
+class CreationMetadata;
+
+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 GetTableRequest;
+
+class GetTableResult;
+
+class GetTablesRequest;
+
+class GetTablesResult;
+
+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 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:
+
+  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), 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:
+
+  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() 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;
+  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);
+
+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), 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:
+
+  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() 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;
+  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);
+
+inline std::ostream& operator<<(std::ostream& out, const SQLForeignKey& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+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:
+
+  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() throw();
+  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);
+
+inline std::ostream& operator<<(std::ostream& out, const SQLUniqueConstraint& 
obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+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:
+
+  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() throw();
+  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);
+
+inline std::ostream& operator<<(std::ostream& out, const SQLNotNullConstraint& 
obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+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:
+
+  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() throw();
+  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);
+
+inline std::ostream& operator<<(std::ostream& out, const SQLDefaultConstraint& 
obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+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:
+
+  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() throw();
+  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);
+
+inline std::ostream& operator<<(std::ostream& out, const SQLCheckConstraint& 
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), 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:
+
+  HiveObjectRef(const HiveObjectRef&);
+  HiveObjectRef& operator=(const HiveObjectRef&);
+  HiveObjectRef() : objectType((HiveObjectType::type)0), dbName(), 
objectName(), columnName(), catName() {
+  }
+
+  virtual ~HiveObjectRef() throw();
+  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);
+
+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), authorizer(false) {}
+  bool hiveObject :1;
+  bool principalName :1;
+  bool principalType :1;
+  bool grantInfo :1;
+  bool authorizer :1;
+} _HiveObjectPrivilege__isset;
+
+class HiveObjectPrivilege {
+ public:
+
+  HiveObjectPrivilege(const HiveObjectPrivilege&);
+  HiveObjectPrivilege& operator=(const HiveObjectPrivilege&);
+  HiveObjectPrivilege() : principalName(), 
principalType((PrincipalType::type)0), authorizer() {
+  }
+
+  virtual ~HiveObjectPrivilege() throw();
+  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);
+
+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 _Catalog__isset {
+  _Catalog__isset() : name(false), description(false), locationUri(false) {}
+  bool name :1;
+  bool description :1;
+  bool locationUri :1;
+} _Catalog__isset;
+
+class Catalog {
+ public:
+
+  Catalog(const Catalog&);
+  Catalog& operator=(const Catalog&);
+  Catalog() : name(), description(), locationUri() {
+  }
+
+  virtual ~Catalog() throw();
+  std::string name;
+  std::string description;
+  std::string locationUri;
+
+  _Catalog__isset __isset;
+
+  void __set_name(const std::string& val);
+
+  void __set_description(const std::string& val);
+
+  void __set_locationUri(const std::string& 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;
+    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);
+
+inline std::ostream& operator<<(std::ostream& out, const Catalog& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _CreateCatalogRequest__isset {
+  _CreateCatalogRequest__isset() : catalog(false) {}
+  bool catalog :1;
+} _CreateCatalogRequest__isset;
+
+class CreateCatalogRequest {
+ public:
+
+  CreateCatalogRequest(const CreateCatalogRequest&);
+  CreateCatalogRequest& operator=(const CreateCatalogRequest&);
+  CreateCatalogRequest() {
+  }
+
+  virtual ~CreateCatalogRequest() throw();
+  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);
+
+inline std::ostream& operator<<(std::ostream& out, const CreateCatalogRequest& 
obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _AlterCatalogRequest__isset {
+  _AlterCatalogRequest__isset() : name(false), newCat(false) {}
+  bool name :1;
+  bool newCat :1;
+} _AlterCatalogRequest__isset;
+
+class AlterCatalogRequest {
+ public:
+
+  AlterCatalogRequest(const AlterCatalogRequest&);
+  AlterCatalogRequest& operator=(const AlterCatalogRequest&);
+  AlterCatalogRequest() : name() {
+  }
+
+  virtual ~AlterCatalogRequest() throw();
+  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);
+
+inline std::ostream& operator<<(std::ostream& out, const AlterCatalogRequest& 
obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _GetCatalogRequest__isset {
+  _GetCatalogRequest__isset() : name(false) {}
+  bool name :1;
+} _GetCatalogRequest__isset;
+
+class GetCatalogRequest {
+ public:
+
+  GetCatalogRequest(const GetCatalogRequest&);
+  GetCatalogRequest& operator=(const GetCatalogRequest&);
+  GetCatalogRequest() : name() {
+  }
+
+  virtual ~GetCatalogRequest() throw();
+  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);
+
+inline std::ostream& operator<<(std::ostream& out, const GetCatalogRequest& 
obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _GetCatalogResponse__isset {
+  _GetCatalogResponse__isset() : catalog(false) {}
+  bool catalog :1;
+} _GetCatalogResponse__isset;
+
+class GetCatalogResponse {
+ public:
+
+  GetCatalogResponse(const GetCatalogResponse&);
+  GetCatalogResponse& operator=(const GetCatalogResponse&);
+  GetCatalogResponse() {
+  }
+
+  virtual ~GetCatalogResponse() throw();
+  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);
+
+inline std::ostream& operator<<(std::ostream& out, const GetCatalogResponse& 
obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _GetCatalogsResponse__isset {
+  _GetCatalogsResponse__isset() : names(false) {}
+  bool names :1;
+} _GetCatalogsResponse__isset;
+
+class GetCatalogsResponse {
+ public:
+
+  GetCatalogsResponse(const GetCatalogsResponse&);
+  GetCatalogsResponse& operator=(const GetCatalogsResponse&);
+  GetCatalogsResponse() {
+  }
+
+  virtual ~GetCatalogsResponse() throw();
+  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);
+
+inline std::ostream& operator<<(std::ostream& out, const GetCatalogsResponse& 
obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _DropCatalogRequest__isset {
+  _DropCatalogRequest__isset() : name(false) {}
+  bool name :1;
+} _DropCatalogRequest__isset;
+
+class DropCatalogRequest {
+ public:
+
+  DropCatalogRequest(const DropCatalogRequest&);
+  DropCatalogRequest& operator=(const DropCatalogRequest&);
+  DropCatalogRequest() : name() {
+  }
+
+  virtual ~DropCatalogRequest() throw();
+  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);
+
+inline std::ostream& operator<<(std::ostream& out, const DropCatalogRequest& 
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), 
catalogName(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;
+} _Database__isset;
+
+class Database {
+ public:
+
+  Database(const Database&);
+  Database& operator=(const Database&);
+  Database() : name(), description(), locationUri(), ownerName(), 
ownerType((PrincipalType::type)0), catalogName() {
+  }
+
+  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;
+  std::string catalogName;
+
+  _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);
+
+  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;
+    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), 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:
+
+  SerDeInfo(const SerDeInfo&);
+  SerDeInfo& operator=(const SerDeInfo&);
+  SerDeInfo() : name(), serializationLib(), description(), serializerClass(), 
deserializerClass(), serdeType((SerdeType::type)0) {
+  }
+
+  virtual ~SerDeInfo() throw();
+  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);
+
+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), creationMetadata(false), catName(false), ownerType(true) 
{}
+  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;
+} _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), catName(), 
ownerType((PrincipalType::type)1) {
+    ownerType = (PrincipalType::type)1;
+
+  }
+
+  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;
+  CreationMetadata creationMetadata;
+  std::string catName;
+  PrincipalType::type ownerType;
+
+  _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);
+
+  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;
+    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), catName(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;
+} _Partition__isset;
+
+class Partition {
+ public:
+
+  Partition(const Partition&);
+  Partition& operator=(const Partition&);
+  Partition() : dbName(), tableName(), createTime(0), lastAccessTime(0), 
catName() {
+  }
+
+  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;
+  std::string catName;
+
+  _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);
+
+  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;
+    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

<TRUNCATED>