Return-Path: 
 <commits-return-16318-apmail-hive-commits-archive=hive.apache.org@hive.apache.org>
X-Original-To: apmail-hive-commits-archive@www.apache.org
Delivered-To: apmail-hive-commits-archive@www.apache.org
Received: from mail.apache.org (hermes.apache.org [140.211.11.3])
	by minotaur.apache.org (Postfix) with SMTP id 8DB3718D8B
	for <apmail-hive-commits-archive@www.apache.org>;
 Fri, 31 Jul 2015 22:57:15 +0000 (UTC)
Received: (qmail 17595 invoked by uid 500); 31 Jul 2015 22:57:06 -0000
Delivered-To: apmail-hive-commits-archive@hive.apache.org
Received: (qmail 17274 invoked by uid 500); 31 Jul 2015 22:57:06 -0000
Mailing-List: contact commits-help@hive.apache.org; run by ezmlm
Precedence: bulk
List-Help: <mailto:commits-help@hive.apache.org>
List-Unsubscribe: <mailto:commits-unsubscribe@hive.apache.org>
List-Post: <mailto:commits@hive.apache.org>
List-Id: <commits.hive.apache.org>
Reply-To: hive-dev@hive.apache.org
Delivered-To: mailing list commits@hive.apache.org
Received: (qmail 13590 invoked by uid 99); 31 Jul 2015 22:57:03 -0000
Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org)
 (140.211.11.23)
    by apache.org (qpsmtpd/0.29) with ESMTP; Fri, 31 Jul 2015 22:57:03 +0000
Received: by git1-us-west.apache.org (ASF Mail Server at
 git1-us-west.apache.org, from userid 33)
	id 41F3FE095F; Fri, 31 Jul 2015 22:57:03 +0000 (UTC)
Content-Type: text/plain; charset="us-ascii"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
From: xuefu@apache.org
To: commits@hive.apache.org
Date: Fri, 31 Jul 2015 22:57:44 -0000
Message-Id: <67f003b65b404f1881b4fd95f32574c6@git.apache.org>
In-Reply-To: <8ac17ffb2a0d4a9e83b90ea91818ea51@git.apache.org>
References: <8ac17ffb2a0d4a9e83b90ea91818ea51@git.apache.org>
X-Mailer: ASF-Git Admin Mailer
Subject: [43/54] [abbrv] hive git commit: HIVE-9152 - Dynamic Partition
 Pruning [Spark Branch] (Chao Sun, reviewed by Xuefu Zhang and Chengxiang Li)

http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
index 9c91650..9dae61c 100644
--- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
+++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
@@ -7,11 +7,14 @@
 #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"
 
 
@@ -134,10 +137,226 @@ struct ResourceType {
 
 extern const std::map<int, const char*> _ResourceType_VALUES_TO_NAMES;
 
+class Version;
+
+class FieldSchema;
+
+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 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 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 ShowCompactRequest;
+
+class ShowCompactResponseElement;
+
+class ShowCompactResponse;
+
+class AddDynamicPartitions;
+
+class NotificationEventRequest;
+
+class NotificationEvent;
+
+class NotificationEventResponse;
+
+class CurrentNotificationEventId;
+
+class InsertEventRequestData;
+
+class FireEventRequestData;
+
+class FireEventRequest;
+
+class FireEventResponse;
+
+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;
-  bool comments;
+  bool version :1;
+  bool comments :1;
 } _Version__isset;
 
 class Version {
@@ -146,23 +365,20 @@ class Version {
   static const char* ascii_fingerprint; // = "07A9615F837F7D0A952B595DD3020972";
   static const uint8_t binary_fingerprint[16]; // = {0x07,0xA9,0x61,0x5F,0x83,0x7F,0x7D,0x0A,0x95,0x2B,0x59,0x5D,0xD3,0x02,0x09,0x72};
 
+  Version(const Version&);
+  Version& operator=(const Version&);
   Version() : version(), comments() {
   }
 
-  virtual ~Version() throw() {}
-
+  virtual ~Version() throw();
   std::string version;
   std::string comments;
 
   _Version__isset __isset;
 
-  void __set_version(const std::string& val) {
-    version = val;
-  }
+  void __set_version(const std::string& val);
 
-  void __set_comments(const std::string& val) {
-    comments = val;
-  }
+  void __set_comments(const std::string& val);
 
   bool operator == (const Version & rhs) const
   {
@@ -181,15 +397,16 @@ class Version {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const Version& obj);
 };
 
 void swap(Version &a, Version &b);
 
 typedef struct _FieldSchema__isset {
   _FieldSchema__isset() : name(false), type(false), comment(false) {}
-  bool name;
-  bool type;
-  bool comment;
+  bool name :1;
+  bool type :1;
+  bool comment :1;
 } _FieldSchema__isset;
 
 class FieldSchema {
@@ -198,28 +415,23 @@ class FieldSchema {
   static const char* ascii_fingerprint; // = "AB879940BD15B6B25691265F7384B271";
   static const uint8_t binary_fingerprint[16]; // = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71};
 
+  FieldSchema(const FieldSchema&);
+  FieldSchema& operator=(const FieldSchema&);
   FieldSchema() : name(), type(), comment() {
   }
 
-  virtual ~FieldSchema() throw() {}
-
+  virtual ~FieldSchema() throw();
   std::string name;
   std::string type;
   std::string comment;
 
   _FieldSchema__isset __isset;
 
-  void __set_name(const std::string& val) {
-    name = val;
-  }
+  void __set_name(const std::string& val);
 
-  void __set_type(const std::string& val) {
-    type = val;
-  }
+  void __set_type(const std::string& val);
 
-  void __set_comment(const std::string& val) {
-    comment = val;
-  }
+  void __set_comment(const std::string& val);
 
   bool operator == (const FieldSchema & rhs) const
   {
@@ -240,16 +452,17 @@ class FieldSchema {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const FieldSchema& obj);
 };
 
 void swap(FieldSchema &a, FieldSchema &b);
 
 typedef struct _Type__isset {
   _Type__isset() : name(false), type1(false), type2(false), fields(false) {}
-  bool name;
-  bool type1;
-  bool type2;
-  bool fields;
+  bool name :1;
+  bool type1 :1;
+  bool type2 :1;
+  bool fields :1;
 } _Type__isset;
 
 class Type {
@@ -258,11 +471,12 @@ class Type {
   static const char* ascii_fingerprint; // = "20DF02DE523C27F7066C7BD4D9120842";
   static const uint8_t binary_fingerprint[16]; // = {0x20,0xDF,0x02,0xDE,0x52,0x3C,0x27,0xF7,0x06,0x6C,0x7B,0xD4,0xD9,0x12,0x08,0x42};
 
+  Type(const Type&);
+  Type& operator=(const Type&);
   Type() : name(), type1(), type2() {
   }
 
-  virtual ~Type() throw() {}
-
+  virtual ~Type() throw();
   std::string name;
   std::string type1;
   std::string type2;
@@ -270,24 +484,13 @@ class Type {
 
   _Type__isset __isset;
 
-  void __set_name(const std::string& val) {
-    name = val;
-  }
+  void __set_name(const std::string& val);
 
-  void __set_type1(const std::string& val) {
-    type1 = val;
-    __isset.type1 = true;
-  }
+  void __set_type1(const std::string& val);
 
-  void __set_type2(const std::string& val) {
-    type2 = val;
-    __isset.type2 = true;
-  }
+  void __set_type2(const std::string& val);
 
-  void __set_fields(const std::vector<FieldSchema> & val) {
-    fields = val;
-    __isset.fields = true;
-  }
+  void __set_fields(const std::vector<FieldSchema> & val);
 
   bool operator == (const Type & rhs) const
   {
@@ -316,17 +519,18 @@ class Type {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const Type& obj);
 };
 
 void swap(Type &a, Type &b);
 
 typedef struct _HiveObjectRef__isset {
   _HiveObjectRef__isset() : objectType(false), dbName(false), objectName(false), partValues(false), columnName(false) {}
-  bool objectType;
-  bool dbName;
-  bool objectName;
-  bool partValues;
-  bool columnName;
+  bool objectType :1;
+  bool dbName :1;
+  bool objectName :1;
+  bool partValues :1;
+  bool columnName :1;
 } _HiveObjectRef__isset;
 
 class HiveObjectRef {
@@ -335,11 +539,12 @@ class HiveObjectRef {
   static const char* ascii_fingerprint; // = "205CD8311CF3AA9EC161BAEF8D7C933C";
   static const uint8_t binary_fingerprint[16]; // = {0x20,0x5C,0xD8,0x31,0x1C,0xF3,0xAA,0x9E,0xC1,0x61,0xBA,0xEF,0x8D,0x7C,0x93,0x3C};
 
+  HiveObjectRef(const HiveObjectRef&);
+  HiveObjectRef& operator=(const HiveObjectRef&);
   HiveObjectRef() : objectType((HiveObjectType::type)0), dbName(), objectName(), columnName() {
   }
 
-  virtual ~HiveObjectRef() throw() {}
-
+  virtual ~HiveObjectRef() throw();
   HiveObjectType::type objectType;
   std::string dbName;
   std::string objectName;
@@ -348,25 +553,15 @@ class HiveObjectRef {
 
   _HiveObjectRef__isset __isset;
 
-  void __set_objectType(const HiveObjectType::type val) {
-    objectType = val;
-  }
+  void __set_objectType(const HiveObjectType::type val);
 
-  void __set_dbName(const std::string& val) {
-    dbName = val;
-  }
+  void __set_dbName(const std::string& val);
 
-  void __set_objectName(const std::string& val) {
-    objectName = val;
-  }
+  void __set_objectName(const std::string& val);
 
-  void __set_partValues(const std::vector<std::string> & val) {
-    partValues = val;
-  }
+  void __set_partValues(const std::vector<std::string> & val);
 
-  void __set_columnName(const std::string& val) {
-    columnName = val;
-  }
+  void __set_columnName(const std::string& val);
 
   bool operator == (const HiveObjectRef & rhs) const
   {
@@ -391,17 +586,18 @@ class HiveObjectRef {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const HiveObjectRef& obj);
 };
 
 void swap(HiveObjectRef &a, HiveObjectRef &b);
 
 typedef struct _PrivilegeGrantInfo__isset {
   _PrivilegeGrantInfo__isset() : privilege(false), createTime(false), grantor(false), grantorType(false), grantOption(false) {}
-  bool privilege;
-  bool createTime;
-  bool grantor;
-  bool grantorType;
-  bool grantOption;
+  bool privilege :1;
+  bool createTime :1;
+  bool grantor :1;
+  bool grantorType :1;
+  bool grantOption :1;
 } _PrivilegeGrantInfo__isset;
 
 class PrivilegeGrantInfo {
@@ -410,11 +606,12 @@ class PrivilegeGrantInfo {
   static const char* ascii_fingerprint; // = "A58923AF7294BE492D6F90E07E8CEE1F";
   static const uint8_t binary_fingerprint[16]; // = {0xA5,0x89,0x23,0xAF,0x72,0x94,0xBE,0x49,0x2D,0x6F,0x90,0xE0,0x7E,0x8C,0xEE,0x1F};
 
+  PrivilegeGrantInfo(const PrivilegeGrantInfo&);
+  PrivilegeGrantInfo& operator=(const PrivilegeGrantInfo&);
   PrivilegeGrantInfo() : privilege(), createTime(0), grantor(), grantorType((PrincipalType::type)0), grantOption(0) {
   }
 
-  virtual ~PrivilegeGrantInfo() throw() {}
-
+  virtual ~PrivilegeGrantInfo() throw();
   std::string privilege;
   int32_t createTime;
   std::string grantor;
@@ -423,25 +620,15 @@ class PrivilegeGrantInfo {
 
   _PrivilegeGrantInfo__isset __isset;
 
-  void __set_privilege(const std::string& val) {
-    privilege = val;
-  }
+  void __set_privilege(const std::string& val);
 
-  void __set_createTime(const int32_t val) {
-    createTime = val;
-  }
+  void __set_createTime(const int32_t val);
 
-  void __set_grantor(const std::string& val) {
-    grantor = val;
-  }
+  void __set_grantor(const std::string& val);
 
-  void __set_grantorType(const PrincipalType::type val) {
-    grantorType = val;
-  }
+  void __set_grantorType(const PrincipalType::type val);
 
-  void __set_grantOption(const bool val) {
-    grantOption = val;
-  }
+  void __set_grantOption(const bool val);
 
   bool operator == (const PrivilegeGrantInfo & rhs) const
   {
@@ -466,16 +653,17 @@ class PrivilegeGrantInfo {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const PrivilegeGrantInfo& obj);
 };
 
 void swap(PrivilegeGrantInfo &a, PrivilegeGrantInfo &b);
 
 typedef struct _HiveObjectPrivilege__isset {
   _HiveObjectPrivilege__isset() : hiveObject(false), principalName(false), principalType(false), grantInfo(false) {}
-  bool hiveObject;
-  bool principalName;
-  bool principalType;
-  bool grantInfo;
+  bool hiveObject :1;
+  bool principalName :1;
+  bool principalType :1;
+  bool grantInfo :1;
 } _HiveObjectPrivilege__isset;
 
 class HiveObjectPrivilege {
@@ -484,11 +672,12 @@ class HiveObjectPrivilege {
   static const char* ascii_fingerprint; // = "83D71969B23BD853E29DBA9D43B29AF8";
   static const uint8_t binary_fingerprint[16]; // = {0x83,0xD7,0x19,0x69,0xB2,0x3B,0xD8,0x53,0xE2,0x9D,0xBA,0x9D,0x43,0xB2,0x9A,0xF8};
 
+  HiveObjectPrivilege(const HiveObjectPrivilege&);
+  HiveObjectPrivilege& operator=(const HiveObjectPrivilege&);
   HiveObjectPrivilege() : principalName(), principalType((PrincipalType::type)0) {
   }
 
-  virtual ~HiveObjectPrivilege() throw() {}
-
+  virtual ~HiveObjectPrivilege() throw();
   HiveObjectRef hiveObject;
   std::string principalName;
   PrincipalType::type principalType;
@@ -496,21 +685,13 @@ class HiveObjectPrivilege {
 
   _HiveObjectPrivilege__isset __isset;
 
-  void __set_hiveObject(const HiveObjectRef& val) {
-    hiveObject = val;
-  }
+  void __set_hiveObject(const HiveObjectRef& val);
 
-  void __set_principalName(const std::string& val) {
-    principalName = val;
-  }
+  void __set_principalName(const std::string& val);
 
-  void __set_principalType(const PrincipalType::type val) {
-    principalType = val;
-  }
+  void __set_principalType(const PrincipalType::type val);
 
-  void __set_grantInfo(const PrivilegeGrantInfo& val) {
-    grantInfo = val;
-  }
+  void __set_grantInfo(const PrivilegeGrantInfo& val);
 
   bool operator == (const HiveObjectPrivilege & rhs) const
   {
@@ -533,13 +714,14 @@ class HiveObjectPrivilege {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const HiveObjectPrivilege& obj);
 };
 
 void swap(HiveObjectPrivilege &a, HiveObjectPrivilege &b);
 
 typedef struct _PrivilegeBag__isset {
   _PrivilegeBag__isset() : privileges(false) {}
-  bool privileges;
+  bool privileges :1;
 } _PrivilegeBag__isset;
 
 class PrivilegeBag {
@@ -548,18 +730,17 @@ class PrivilegeBag {
   static const char* ascii_fingerprint; // = "BB89E4701B7B709B046A74C90B1147F2";
   static const uint8_t binary_fingerprint[16]; // = {0xBB,0x89,0xE4,0x70,0x1B,0x7B,0x70,0x9B,0x04,0x6A,0x74,0xC9,0x0B,0x11,0x47,0xF2};
 
+  PrivilegeBag(const PrivilegeBag&);
+  PrivilegeBag& operator=(const PrivilegeBag&);
   PrivilegeBag() {
   }
 
-  virtual ~PrivilegeBag() throw() {}
-
+  virtual ~PrivilegeBag() throw();
   std::vector<HiveObjectPrivilege>  privileges;
 
   _PrivilegeBag__isset __isset;
 
-  void __set_privileges(const std::vector<HiveObjectPrivilege> & val) {
-    privileges = val;
-  }
+  void __set_privileges(const std::vector<HiveObjectPrivilege> & val);
 
   bool operator == (const PrivilegeBag & rhs) const
   {
@@ -576,15 +757,16 @@ class PrivilegeBag {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const PrivilegeBag& obj);
 };
 
 void swap(PrivilegeBag &a, PrivilegeBag &b);
 
 typedef struct _PrincipalPrivilegeSet__isset {
   _PrincipalPrivilegeSet__isset() : userPrivileges(false), groupPrivileges(false), rolePrivileges(false) {}
-  bool userPrivileges;
-  bool groupPrivileges;
-  bool rolePrivileges;
+  bool userPrivileges :1;
+  bool groupPrivileges :1;
+  bool rolePrivileges :1;
 } _PrincipalPrivilegeSet__isset;
 
 class PrincipalPrivilegeSet {
@@ -593,28 +775,23 @@ class PrincipalPrivilegeSet {
   static const char* ascii_fingerprint; // = "08F75D2533906EA87BE34EA640856683";
   static const uint8_t binary_fingerprint[16]; // = {0x08,0xF7,0x5D,0x25,0x33,0x90,0x6E,0xA8,0x7B,0xE3,0x4E,0xA6,0x40,0x85,0x66,0x83};
 
+  PrincipalPrivilegeSet(const PrincipalPrivilegeSet&);
+  PrincipalPrivilegeSet& operator=(const PrincipalPrivilegeSet&);
   PrincipalPrivilegeSet() {
   }
 
-  virtual ~PrincipalPrivilegeSet() throw() {}
-
+  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) {
-    userPrivileges = val;
-  }
+  void __set_userPrivileges(const std::map<std::string, std::vector<PrivilegeGrantInfo> > & val);
 
-  void __set_groupPrivileges(const std::map<std::string, std::vector<PrivilegeGrantInfo> > & val) {
-    groupPrivileges = 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) {
-    rolePrivileges = val;
-  }
+  void __set_rolePrivileges(const std::map<std::string, std::vector<PrivilegeGrantInfo> > & val);
 
   bool operator == (const PrincipalPrivilegeSet & rhs) const
   {
@@ -635,15 +812,16 @@ class PrincipalPrivilegeSet {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const PrincipalPrivilegeSet& obj);
 };
 
 void swap(PrincipalPrivilegeSet &a, PrincipalPrivilegeSet &b);
 
 typedef struct _GrantRevokePrivilegeRequest__isset {
   _GrantRevokePrivilegeRequest__isset() : requestType(false), privileges(false), revokeGrantOption(false) {}
-  bool requestType;
-  bool privileges;
-  bool revokeGrantOption;
+  bool requestType :1;
+  bool privileges :1;
+  bool revokeGrantOption :1;
 } _GrantRevokePrivilegeRequest__isset;
 
 class GrantRevokePrivilegeRequest {
@@ -652,29 +830,23 @@ class GrantRevokePrivilegeRequest {
   static const char* ascii_fingerprint; // = "DF474A3CB526AD40DC0F2C3702F7AA2C";
   static const uint8_t binary_fingerprint[16]; // = {0xDF,0x47,0x4A,0x3C,0xB5,0x26,0xAD,0x40,0xDC,0x0F,0x2C,0x37,0x02,0xF7,0xAA,0x2C};
 
+  GrantRevokePrivilegeRequest(const GrantRevokePrivilegeRequest&);
+  GrantRevokePrivilegeRequest& operator=(const GrantRevokePrivilegeRequest&);
   GrantRevokePrivilegeRequest() : requestType((GrantRevokeType::type)0), revokeGrantOption(0) {
   }
 
-  virtual ~GrantRevokePrivilegeRequest() throw() {}
-
+  virtual ~GrantRevokePrivilegeRequest() throw();
   GrantRevokeType::type requestType;
   PrivilegeBag privileges;
   bool revokeGrantOption;
 
   _GrantRevokePrivilegeRequest__isset __isset;
 
-  void __set_requestType(const GrantRevokeType::type val) {
-    requestType = val;
-  }
+  void __set_requestType(const GrantRevokeType::type val);
 
-  void __set_privileges(const PrivilegeBag& val) {
-    privileges = val;
-  }
+  void __set_privileges(const PrivilegeBag& val);
 
-  void __set_revokeGrantOption(const bool val) {
-    revokeGrantOption = val;
-    __isset.revokeGrantOption = true;
-  }
+  void __set_revokeGrantOption(const bool val);
 
   bool operator == (const GrantRevokePrivilegeRequest & rhs) const
   {
@@ -697,13 +869,14 @@ class GrantRevokePrivilegeRequest {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const GrantRevokePrivilegeRequest& obj);
 };
 
 void swap(GrantRevokePrivilegeRequest &a, GrantRevokePrivilegeRequest &b);
 
 typedef struct _GrantRevokePrivilegeResponse__isset {
   _GrantRevokePrivilegeResponse__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _GrantRevokePrivilegeResponse__isset;
 
 class GrantRevokePrivilegeResponse {
@@ -712,19 +885,17 @@ class GrantRevokePrivilegeResponse {
   static const char* ascii_fingerprint; // = "BF054652DEF86253C2BEE7D947F167DD";
   static const uint8_t binary_fingerprint[16]; // = {0xBF,0x05,0x46,0x52,0xDE,0xF8,0x62,0x53,0xC2,0xBE,0xE7,0xD9,0x47,0xF1,0x67,0xDD};
 
+  GrantRevokePrivilegeResponse(const GrantRevokePrivilegeResponse&);
+  GrantRevokePrivilegeResponse& operator=(const GrantRevokePrivilegeResponse&);
   GrantRevokePrivilegeResponse() : success(0) {
   }
 
-  virtual ~GrantRevokePrivilegeResponse() throw() {}
-
+  virtual ~GrantRevokePrivilegeResponse() throw();
   bool success;
 
   _GrantRevokePrivilegeResponse__isset __isset;
 
-  void __set_success(const bool val) {
-    success = val;
-    __isset.success = true;
-  }
+  void __set_success(const bool val);
 
   bool operator == (const GrantRevokePrivilegeResponse & rhs) const
   {
@@ -743,15 +914,16 @@ class GrantRevokePrivilegeResponse {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const GrantRevokePrivilegeResponse& obj);
 };
 
 void swap(GrantRevokePrivilegeResponse &a, GrantRevokePrivilegeResponse &b);
 
 typedef struct _Role__isset {
   _Role__isset() : roleName(false), createTime(false), ownerName(false) {}
-  bool roleName;
-  bool createTime;
-  bool ownerName;
+  bool roleName :1;
+  bool createTime :1;
+  bool ownerName :1;
 } _Role__isset;
 
 class Role {
@@ -760,28 +932,23 @@ class Role {
   static const char* ascii_fingerprint; // = "70563A0628F75DF9555F4D24690B1E26";
   static const uint8_t binary_fingerprint[16]; // = {0x70,0x56,0x3A,0x06,0x28,0xF7,0x5D,0xF9,0x55,0x5F,0x4D,0x24,0x69,0x0B,0x1E,0x26};
 
+  Role(const Role&);
+  Role& operator=(const Role&);
   Role() : roleName(), createTime(0), ownerName() {
   }
 
-  virtual ~Role() throw() {}
-
+  virtual ~Role() throw();
   std::string roleName;
   int32_t createTime;
   std::string ownerName;
 
   _Role__isset __isset;
 
-  void __set_roleName(const std::string& val) {
-    roleName = val;
-  }
+  void __set_roleName(const std::string& val);
 
-  void __set_createTime(const int32_t val) {
-    createTime = val;
-  }
+  void __set_createTime(const int32_t val);
 
-  void __set_ownerName(const std::string& val) {
-    ownerName = val;
-  }
+  void __set_ownerName(const std::string& val);
 
   bool operator == (const Role & rhs) const
   {
@@ -802,19 +969,20 @@ class Role {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const Role& obj);
 };
 
 void swap(Role &a, Role &b);
 
 typedef struct _RolePrincipalGrant__isset {
   _RolePrincipalGrant__isset() : roleName(false), principalName(false), principalType(false), grantOption(false), grantTime(false), grantorName(false), grantorPrincipalType(false) {}
-  bool roleName;
-  bool principalName;
-  bool principalType;
-  bool grantOption;
-  bool grantTime;
-  bool grantorName;
-  bool grantorPrincipalType;
+  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 {
@@ -823,11 +991,12 @@ class RolePrincipalGrant {
   static const char* ascii_fingerprint; // = "899BA3F6214DD1B79D27206BA857C772";
   static const uint8_t binary_fingerprint[16]; // = {0x89,0x9B,0xA3,0xF6,0x21,0x4D,0xD1,0xB7,0x9D,0x27,0x20,0x6B,0xA8,0x57,0xC7,0x72};
 
+  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() {}
-
+  virtual ~RolePrincipalGrant() throw();
   std::string roleName;
   std::string principalName;
   PrincipalType::type principalType;
@@ -838,33 +1007,19 @@ class RolePrincipalGrant {
 
   _RolePrincipalGrant__isset __isset;
 
-  void __set_roleName(const std::string& val) {
-    roleName = val;
-  }
+  void __set_roleName(const std::string& val);
 
-  void __set_principalName(const std::string& val) {
-    principalName = val;
-  }
+  void __set_principalName(const std::string& val);
 
-  void __set_principalType(const PrincipalType::type val) {
-    principalType = val;
-  }
+  void __set_principalType(const PrincipalType::type val);
 
-  void __set_grantOption(const bool val) {
-    grantOption = val;
-  }
+  void __set_grantOption(const bool val);
 
-  void __set_grantTime(const int32_t val) {
-    grantTime = val;
-  }
+  void __set_grantTime(const int32_t val);
 
-  void __set_grantorName(const std::string& val) {
-    grantorName = val;
-  }
+  void __set_grantorName(const std::string& val);
 
-  void __set_grantorPrincipalType(const PrincipalType::type val) {
-    grantorPrincipalType = val;
-  }
+  void __set_grantorPrincipalType(const PrincipalType::type val);
 
   bool operator == (const RolePrincipalGrant & rhs) const
   {
@@ -893,6 +1048,7 @@ class RolePrincipalGrant {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const RolePrincipalGrant& obj);
 };
 
 void swap(RolePrincipalGrant &a, RolePrincipalGrant &b);
@@ -904,21 +1060,18 @@ class GetRoleGrantsForPrincipalRequest {
   static const char* ascii_fingerprint; // = "D6FD826D949221396F4FFC3ECCD3D192";
   static const uint8_t binary_fingerprint[16]; // = {0xD6,0xFD,0x82,0x6D,0x94,0x92,0x21,0x39,0x6F,0x4F,0xFC,0x3E,0xCC,0xD3,0xD1,0x92};
 
+  GetRoleGrantsForPrincipalRequest(const GetRoleGrantsForPrincipalRequest&);
+  GetRoleGrantsForPrincipalRequest& operator=(const GetRoleGrantsForPrincipalRequest&);
   GetRoleGrantsForPrincipalRequest() : principal_name(), principal_type((PrincipalType::type)0) {
   }
 
-  virtual ~GetRoleGrantsForPrincipalRequest() throw() {}
-
+  virtual ~GetRoleGrantsForPrincipalRequest() throw();
   std::string principal_name;
   PrincipalType::type principal_type;
 
-  void __set_principal_name(const std::string& val) {
-    principal_name = val;
-  }
+  void __set_principal_name(const std::string& val);
 
-  void __set_principal_type(const PrincipalType::type val) {
-    principal_type = val;
-  }
+  void __set_principal_type(const PrincipalType::type val);
 
   bool operator == (const GetRoleGrantsForPrincipalRequest & rhs) const
   {
@@ -937,6 +1090,7 @@ class GetRoleGrantsForPrincipalRequest {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const GetRoleGrantsForPrincipalRequest& obj);
 };
 
 void swap(GetRoleGrantsForPrincipalRequest &a, GetRoleGrantsForPrincipalRequest &b);
@@ -948,16 +1102,15 @@ class GetRoleGrantsForPrincipalResponse {
   static const char* ascii_fingerprint; // = "5926B4B3541A62E17663820C7E3BE690";
   static const uint8_t binary_fingerprint[16]; // = {0x59,0x26,0xB4,0xB3,0x54,0x1A,0x62,0xE1,0x76,0x63,0x82,0x0C,0x7E,0x3B,0xE6,0x90};
 
+  GetRoleGrantsForPrincipalResponse(const GetRoleGrantsForPrincipalResponse&);
+  GetRoleGrantsForPrincipalResponse& operator=(const GetRoleGrantsForPrincipalResponse&);
   GetRoleGrantsForPrincipalResponse() {
   }
 
-  virtual ~GetRoleGrantsForPrincipalResponse() throw() {}
-
+  virtual ~GetRoleGrantsForPrincipalResponse() throw();
   std::vector<RolePrincipalGrant>  principalGrants;
 
-  void __set_principalGrants(const std::vector<RolePrincipalGrant> & val) {
-    principalGrants = val;
-  }
+  void __set_principalGrants(const std::vector<RolePrincipalGrant> & val);
 
   bool operator == (const GetRoleGrantsForPrincipalResponse & rhs) const
   {
@@ -974,6 +1127,7 @@ class GetRoleGrantsForPrincipalResponse {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const GetRoleGrantsForPrincipalResponse& obj);
 };
 
 void swap(GetRoleGrantsForPrincipalResponse &a, GetRoleGrantsForPrincipalResponse &b);
@@ -985,16 +1139,15 @@ class GetPrincipalsInRoleRequest {
   static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
   static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
 
+  GetPrincipalsInRoleRequest(const GetPrincipalsInRoleRequest&);
+  GetPrincipalsInRoleRequest& operator=(const GetPrincipalsInRoleRequest&);
   GetPrincipalsInRoleRequest() : roleName() {
   }
 
-  virtual ~GetPrincipalsInRoleRequest() throw() {}
-
+  virtual ~GetPrincipalsInRoleRequest() throw();
   std::string roleName;
 
-  void __set_roleName(const std::string& val) {
-    roleName = val;
-  }
+  void __set_roleName(const std::string& val);
 
   bool operator == (const GetPrincipalsInRoleRequest & rhs) const
   {
@@ -1011,6 +1164,7 @@ class GetPrincipalsInRoleRequest {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const GetPrincipalsInRoleRequest& obj);
 };
 
 void swap(GetPrincipalsInRoleRequest &a, GetPrincipalsInRoleRequest &b);
@@ -1022,16 +1176,15 @@ class GetPrincipalsInRoleResponse {
   static const char* ascii_fingerprint; // = "5926B4B3541A62E17663820C7E3BE690";
   static const uint8_t binary_fingerprint[16]; // = {0x59,0x26,0xB4,0xB3,0x54,0x1A,0x62,0xE1,0x76,0x63,0x82,0x0C,0x7E,0x3B,0xE6,0x90};
 
+  GetPrincipalsInRoleResponse(const GetPrincipalsInRoleResponse&);
+  GetPrincipalsInRoleResponse& operator=(const GetPrincipalsInRoleResponse&);
   GetPrincipalsInRoleResponse() {
   }
 
-  virtual ~GetPrincipalsInRoleResponse() throw() {}
-
+  virtual ~GetPrincipalsInRoleResponse() throw();
   std::vector<RolePrincipalGrant>  principalGrants;
 
-  void __set_principalGrants(const std::vector<RolePrincipalGrant> & val) {
-    principalGrants = val;
-  }
+  void __set_principalGrants(const std::vector<RolePrincipalGrant> & val);
 
   bool operator == (const GetPrincipalsInRoleResponse & rhs) const
   {
@@ -1048,19 +1201,20 @@ class GetPrincipalsInRoleResponse {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const GetPrincipalsInRoleResponse& obj);
 };
 
 void swap(GetPrincipalsInRoleResponse &a, GetPrincipalsInRoleResponse &b);
 
 typedef struct _GrantRevokeRoleRequest__isset {
   _GrantRevokeRoleRequest__isset() : requestType(false), roleName(false), principalName(false), principalType(false), grantor(false), grantorType(false), grantOption(false) {}
-  bool requestType;
-  bool roleName;
-  bool principalName;
-  bool principalType;
-  bool grantor;
-  bool grantorType;
-  bool grantOption;
+  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 {
@@ -1069,11 +1223,12 @@ class GrantRevokeRoleRequest {
   static const char* ascii_fingerprint; // = "907DEA796F2BA7AF76DC2566E75FAEE7";
   static const uint8_t binary_fingerprint[16]; // = {0x90,0x7D,0xEA,0x79,0x6F,0x2B,0xA7,0xAF,0x76,0xDC,0x25,0x66,0xE7,0x5F,0xAE,0xE7};
 
+  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() {}
-
+  virtual ~GrantRevokeRoleRequest() throw();
   GrantRevokeType::type requestType;
   std::string roleName;
   std::string principalName;
@@ -1084,36 +1239,19 @@ class GrantRevokeRoleRequest {
 
   _GrantRevokeRoleRequest__isset __isset;
 
-  void __set_requestType(const GrantRevokeType::type val) {
-    requestType = val;
-  }
+  void __set_requestType(const GrantRevokeType::type val);
 
-  void __set_roleName(const std::string& val) {
-    roleName = val;
-  }
+  void __set_roleName(const std::string& val);
 
-  void __set_principalName(const std::string& val) {
-    principalName = val;
-  }
+  void __set_principalName(const std::string& val);
 
-  void __set_principalType(const PrincipalType::type val) {
-    principalType = val;
-  }
+  void __set_principalType(const PrincipalType::type val);
 
-  void __set_grantor(const std::string& val) {
-    grantor = val;
-    __isset.grantor = true;
-  }
+  void __set_grantor(const std::string& val);
 
-  void __set_grantorType(const PrincipalType::type val) {
-    grantorType = val;
-    __isset.grantorType = true;
-  }
+  void __set_grantorType(const PrincipalType::type val);
 
-  void __set_grantOption(const bool val) {
-    grantOption = val;
-    __isset.grantOption = true;
-  }
+  void __set_grantOption(const bool val);
 
   bool operator == (const GrantRevokeRoleRequest & rhs) const
   {
@@ -1148,13 +1286,14 @@ class GrantRevokeRoleRequest {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const GrantRevokeRoleRequest& obj);
 };
 
 void swap(GrantRevokeRoleRequest &a, GrantRevokeRoleRequest &b);
 
 typedef struct _GrantRevokeRoleResponse__isset {
   _GrantRevokeRoleResponse__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _GrantRevokeRoleResponse__isset;
 
 class GrantRevokeRoleResponse {
@@ -1163,19 +1302,17 @@ class GrantRevokeRoleResponse {
   static const char* ascii_fingerprint; // = "BF054652DEF86253C2BEE7D947F167DD";
   static const uint8_t binary_fingerprint[16]; // = {0xBF,0x05,0x46,0x52,0xDE,0xF8,0x62,0x53,0xC2,0xBE,0xE7,0xD9,0x47,0xF1,0x67,0xDD};
 
+  GrantRevokeRoleResponse(const GrantRevokeRoleResponse&);
+  GrantRevokeRoleResponse& operator=(const GrantRevokeRoleResponse&);
   GrantRevokeRoleResponse() : success(0) {
   }
 
-  virtual ~GrantRevokeRoleResponse() throw() {}
-
+  virtual ~GrantRevokeRoleResponse() throw();
   bool success;
 
   _GrantRevokeRoleResponse__isset __isset;
 
-  void __set_success(const bool val) {
-    success = val;
-    __isset.success = true;
-  }
+  void __set_success(const bool val);
 
   bool operator == (const GrantRevokeRoleResponse & rhs) const
   {
@@ -1194,19 +1331,20 @@ class GrantRevokeRoleResponse {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const GrantRevokeRoleResponse& obj);
 };
 
 void swap(GrantRevokeRoleResponse &a, GrantRevokeRoleResponse &b);
 
 typedef struct _Database__isset {
   _Database__isset() : name(false), description(false), locationUri(false), parameters(false), privileges(false), ownerName(false), ownerType(false) {}
-  bool name;
-  bool description;
-  bool locationUri;
-  bool parameters;
-  bool privileges;
-  bool ownerName;
-  bool ownerType;
+  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 {
@@ -1215,11 +1353,12 @@ class Database {
   static const char* ascii_fingerprint; // = "553495CAE243A1C583D5C3DD990AED53";
   static const uint8_t binary_fingerprint[16]; // = {0x55,0x34,0x95,0xCA,0xE2,0x43,0xA1,0xC5,0x83,0xD5,0xC3,0xDD,0x99,0x0A,0xED,0x53};
 
+  Database(const Database&);
+  Database& operator=(const Database&);
   Database() : name(), description(), locationUri(), ownerName(), ownerType((PrincipalType::type)0) {
   }
 
-  virtual ~Database() throw() {}
-
+  virtual ~Database() throw();
   std::string name;
   std::string description;
   std::string locationUri;
@@ -1230,36 +1369,19 @@ class Database {
 
   _Database__isset __isset;
 
-  void __set_name(const std::string& val) {
-    name = val;
-  }
+  void __set_name(const std::string& val);
 
-  void __set_description(const std::string& val) {
-    description = val;
-  }
+  void __set_description(const std::string& val);
 
-  void __set_locationUri(const std::string& val) {
-    locationUri = val;
-  }
+  void __set_locationUri(const std::string& val);
 
-  void __set_parameters(const std::map<std::string, std::string> & val) {
-    parameters = val;
-  }
+  void __set_parameters(const std::map<std::string, std::string> & val);
 
-  void __set_privileges(const PrincipalPrivilegeSet& val) {
-    privileges = val;
-    __isset.privileges = true;
-  }
+  void __set_privileges(const PrincipalPrivilegeSet& val);
 
-  void __set_ownerName(const std::string& val) {
-    ownerName = val;
-    __isset.ownerName = true;
-  }
+  void __set_ownerName(const std::string& val);
 
-  void __set_ownerType(const PrincipalType::type val) {
-    ownerType = val;
-    __isset.ownerType = true;
-  }
+  void __set_ownerType(const PrincipalType::type val);
 
   bool operator == (const Database & rhs) const
   {
@@ -1294,15 +1416,16 @@ class Database {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const Database& obj);
 };
 
 void swap(Database &a, Database &b);
 
 typedef struct _SerDeInfo__isset {
   _SerDeInfo__isset() : name(false), serializationLib(false), parameters(false) {}
-  bool name;
-  bool serializationLib;
-  bool parameters;
+  bool name :1;
+  bool serializationLib :1;
+  bool parameters :1;
 } _SerDeInfo__isset;
 
 class SerDeInfo {
@@ -1311,28 +1434,23 @@ class SerDeInfo {
   static const char* ascii_fingerprint; // = "B1021C32A35A2AEFCD2F57A5424159A7";
   static const uint8_t binary_fingerprint[16]; // = {0xB1,0x02,0x1C,0x32,0xA3,0x5A,0x2A,0xEF,0xCD,0x2F,0x57,0xA5,0x42,0x41,0x59,0xA7};
 
+  SerDeInfo(const SerDeInfo&);
+  SerDeInfo& operator=(const SerDeInfo&);
   SerDeInfo() : name(), serializationLib() {
   }
 
-  virtual ~SerDeInfo() throw() {}
-
+  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) {
-    name = val;
-  }
+  void __set_name(const std::string& val);
 
-  void __set_serializationLib(const std::string& val) {
-    serializationLib = val;
-  }
+  void __set_serializationLib(const std::string& val);
 
-  void __set_parameters(const std::map<std::string, std::string> & val) {
-    parameters = val;
-  }
+  void __set_parameters(const std::map<std::string, std::string> & val);
 
   bool operator == (const SerDeInfo & rhs) const
   {
@@ -1353,14 +1471,15 @@ class SerDeInfo {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const SerDeInfo& obj);
 };
 
 void swap(SerDeInfo &a, SerDeInfo &b);
 
 typedef struct _Order__isset {
   _Order__isset() : col(false), order(false) {}
-  bool col;
-  bool order;
+  bool col :1;
+  bool order :1;
 } _Order__isset;
 
 class Order {
@@ -1369,23 +1488,20 @@ class Order {
   static const char* ascii_fingerprint; // = "EEBC915CE44901401D881E6091423036";
   static const uint8_t binary_fingerprint[16]; // = {0xEE,0xBC,0x91,0x5C,0xE4,0x49,0x01,0x40,0x1D,0x88,0x1E,0x60,0x91,0x42,0x30,0x36};
 
+  Order(const Order&);
+  Order& operator=(const Order&);
   Order() : col(), order(0) {
   }
 
-  virtual ~Order() throw() {}
-
+  virtual ~Order() throw();
   std::string col;
   int32_t order;
 
   _Order__isset __isset;
 
-  void __set_col(const std::string& val) {
-    col = val;
-  }
+  void __set_col(const std::string& val);
 
-  void __set_order(const int32_t val) {
-    order = val;
-  }
+  void __set_order(const int32_t val);
 
   bool operator == (const Order & rhs) const
   {
@@ -1404,15 +1520,16 @@ class Order {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const Order& obj);
 };
 
 void swap(Order &a, Order &b);
 
 typedef struct _SkewedInfo__isset {
   _SkewedInfo__isset() : skewedColNames(false), skewedColValues(false), skewedColValueLocationMaps(false) {}
-  bool skewedColNames;
-  bool skewedColValues;
-  bool skewedColValueLocationMaps;
+  bool skewedColNames :1;
+  bool skewedColValues :1;
+  bool skewedColValueLocationMaps :1;
 } _SkewedInfo__isset;
 
 class SkewedInfo {
@@ -1421,28 +1538,23 @@ class SkewedInfo {
   static const char* ascii_fingerprint; // = "4BF2ED84BC3C3EB297A2AE2FA8427EB1";
   static const uint8_t binary_fingerprint[16]; // = {0x4B,0xF2,0xED,0x84,0xBC,0x3C,0x3E,0xB2,0x97,0xA2,0xAE,0x2F,0xA8,0x42,0x7E,0xB1};
 
+  SkewedInfo(const SkewedInfo&);
+  SkewedInfo& operator=(const SkewedInfo&);
   SkewedInfo() {
   }
 
-  virtual ~SkewedInfo() throw() {}
-
+  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) {
-    skewedColNames = val;
-  }
+  void __set_skewedColNames(const std::vector<std::string> & val);
 
-  void __set_skewedColValues(const std::vector<std::vector<std::string> > & val) {
-    skewedColValues = 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) {
-    skewedColValueLocationMaps = val;
-  }
+  void __set_skewedColValueLocationMaps(const std::map<std::vector<std::string> , std::string> & val);
 
   bool operator == (const SkewedInfo & rhs) const
   {
@@ -1463,24 +1575,25 @@ class SkewedInfo {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const SkewedInfo& obj);
 };
 
 void swap(SkewedInfo &a, SkewedInfo &b);
 
 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;
-  bool location;
-  bool inputFormat;
-  bool outputFormat;
-  bool compressed;
-  bool numBuckets;
-  bool serdeInfo;
-  bool bucketCols;
-  bool sortCols;
-  bool parameters;
-  bool skewedInfo;
-  bool storedAsSubDirectories;
+  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 {
@@ -1489,11 +1602,12 @@ class StorageDescriptor {
   static const char* ascii_fingerprint; // = "CA8C9AA5FE4C32643757D8639CEF0CD7";
   static const uint8_t binary_fingerprint[16]; // = {0xCA,0x8C,0x9A,0xA5,0xFE,0x4C,0x32,0x64,0x37,0x57,0xD8,0x63,0x9C,0xEF,0x0C,0xD7};
 
+  StorageDescriptor(const StorageDescriptor&);
+  StorageDescriptor& operator=(const StorageDescriptor&);
   StorageDescriptor() : location(), inputFormat(), outputFormat(), compressed(0), numBuckets(0), storedAsSubDirectories(0) {
   }
 
-  virtual ~StorageDescriptor() throw() {}
-
+  virtual ~StorageDescriptor() throw();
   std::vector<FieldSchema>  cols;
   std::string location;
   std::string inputFormat;
@@ -1509,55 +1623,29 @@ class StorageDescriptor {
 
   _StorageDescriptor__isset __isset;
 
-  void __set_cols(const std::vector<FieldSchema> & val) {
-    cols = val;
-  }
+  void __set_cols(const std::vector<FieldSchema> & val);
 
-  void __set_location(const std::string& val) {
-    location = val;
-  }
+  void __set_location(const std::string& val);
 
-  void __set_inputFormat(const std::string& val) {
-    inputFormat = val;
-  }
+  void __set_inputFormat(const std::string& val);
 
-  void __set_outputFormat(const std::string& val) {
-    outputFormat = val;
-  }
+  void __set_outputFormat(const std::string& val);
 
-  void __set_compressed(const bool val) {
-    compressed = val;
-  }
+  void __set_compressed(const bool val);
 
-  void __set_numBuckets(const int32_t val) {
-    numBuckets = val;
-  }
+  void __set_numBuckets(const int32_t val);
 
-  void __set_serdeInfo(const SerDeInfo& val) {
-    serdeInfo = val;
-  }
+  void __set_serdeInfo(const SerDeInfo& val);
 
-  void __set_bucketCols(const std::vector<std::string> & val) {
-    bucketCols = val;
-  }
+  void __set_bucketCols(const std::vector<std::string> & val);
 
-  void __set_sortCols(const std::vector<Order> & val) {
-    sortCols = val;
-  }
+  void __set_sortCols(const std::vector<Order> & val);
 
-  void __set_parameters(const std::map<std::string, std::string> & val) {
-    parameters = val;
-  }
+  void __set_parameters(const std::map<std::string, std::string> & val);
 
-  void __set_skewedInfo(const SkewedInfo& val) {
-    skewedInfo = val;
-    __isset.skewedInfo = true;
-  }
+  void __set_skewedInfo(const SkewedInfo& val);
 
-  void __set_storedAsSubDirectories(const bool val) {
-    storedAsSubDirectories = val;
-    __isset.storedAsSubDirectories = true;
-  }
+  void __set_storedAsSubDirectories(const bool val);
 
   bool operator == (const StorageDescriptor & rhs) const
   {
@@ -1600,26 +1688,27 @@ class StorageDescriptor {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const StorageDescriptor& obj);
 };
 
 void swap(StorageDescriptor &a, StorageDescriptor &b);
 
 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) {}
-  bool tableName;
-  bool dbName;
-  bool owner;
-  bool createTime;
-  bool lastAccessTime;
-  bool retention;
-  bool sd;
-  bool partitionKeys;
-  bool parameters;
-  bool viewOriginalText;
-  bool viewExpandedText;
-  bool tableType;
-  bool privileges;
-  bool temporary;
+  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;
 } _Table__isset;
 
 class Table {
@@ -1628,11 +1717,12 @@ class Table {
   static const char* ascii_fingerprint; // = "29EFB2A5970EF572039E5D94CC78AA85";
   static const uint8_t binary_fingerprint[16]; // = {0x29,0xEF,0xB2,0xA5,0x97,0x0E,0xF5,0x72,0x03,0x9E,0x5D,0x94,0xCC,0x78,0xAA,0x85};
 
+  Table(const Table&);
+  Table& operator=(const Table&);
   Table() : tableName(), dbName(), owner(), createTime(0), lastAccessTime(0), retention(0), viewOriginalText(), viewExpandedText(), tableType(), temporary(false) {
   }
 
-  virtual ~Table() throw() {}
-
+  virtual ~Table() throw();
   std::string tableName;
   std::string dbName;
   std::string owner;
@@ -1650,63 +1740,33 @@ class Table {
 
   _Table__isset __isset;
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
-  void __set_dbName(const std::string& val) {
-    dbName = val;
-  }
+  void __set_dbName(const std::string& val);
 
-  void __set_owner(const std::string& val) {
-    owner = val;
-  }
+  void __set_owner(const std::string& val);
 
-  void __set_createTime(const int32_t val) {
-    createTime = val;
-  }
+  void __set_createTime(const int32_t val);
 
-  void __set_lastAccessTime(const int32_t val) {
-    lastAccessTime = val;
-  }
+  void __set_lastAccessTime(const int32_t val);
 
-  void __set_retention(const int32_t val) {
-    retention = val;
-  }
+  void __set_retention(const int32_t val);
 
-  void __set_sd(const StorageDescriptor& val) {
-    sd = val;
-  }
+  void __set_sd(const StorageDescriptor& val);
 
-  void __set_partitionKeys(const std::vector<FieldSchema> & val) {
-    partitionKeys = val;
-  }
+  void __set_partitionKeys(const std::vector<FieldSchema> & val);
 
-  void __set_parameters(const std::map<std::string, std::string> & val) {
-    parameters = val;
-  }
+  void __set_parameters(const std::map<std::string, std::string> & val);
 
-  void __set_viewOriginalText(const std::string& val) {
-    viewOriginalText = val;
-  }
+  void __set_viewOriginalText(const std::string& val);
 
-  void __set_viewExpandedText(const std::string& val) {
-    viewExpandedText = val;
-  }
+  void __set_viewExpandedText(const std::string& val);
 
-  void __set_tableType(const std::string& val) {
-    tableType = val;
-  }
+  void __set_tableType(const std::string& val);
 
-  void __set_privileges(const PrincipalPrivilegeSet& val) {
-    privileges = val;
-    __isset.privileges = true;
-  }
+  void __set_privileges(const PrincipalPrivilegeSet& val);
 
-  void __set_temporary(const bool val) {
-    temporary = val;
-    __isset.temporary = true;
-  }
+  void __set_temporary(const bool val);
 
   bool operator == (const Table & rhs) const
   {
@@ -1753,20 +1813,21 @@ class Table {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const Table& obj);
 };
 
 void swap(Table &a, Table &b);
 
 typedef struct _Partition__isset {
   _Partition__isset() : values(false), dbName(false), tableName(false), createTime(false), lastAccessTime(false), sd(false), parameters(false), privileges(false) {}
-  bool values;
-  bool dbName;
-  bool tableName;
-  bool createTime;
-  bool lastAccessTime;
-  bool sd;
-  bool parameters;
-  bool privileges;
+  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 {
@@ -1775,11 +1836,12 @@ class Partition {
   static const char* ascii_fingerprint; // = "31A52241B88A426C34087FE38343FF51";
   static const uint8_t binary_fingerprint[16]; // = {0x31,0xA5,0x22,0x41,0xB8,0x8A,0x42,0x6C,0x34,0x08,0x7F,0xE3,0x83,0x43,0xFF,0x51};
 
+  Partition(const Partition&);
+  Partition& operator=(const Partition&);
   Partition() : dbName(), tableName(), createTime(0), lastAccessTime(0) {
   }
 
-  virtual ~Partition() throw() {}
-
+  virtual ~Partition() throw();
   std::vector<std::string>  values;
   std::string dbName;
   std::string tableName;
@@ -1791,38 +1853,21 @@ class Partition {
 
   _Partition__isset __isset;
 
-  void __set_values(const std::vector<std::string> & val) {
-    values = val;
-  }
+  void __set_values(const std::vector<std::string> & val);
 
-  void __set_dbName(const std::string& val) {
-    dbName = val;
-  }
+  void __set_dbName(const std::string& val);
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
-  void __set_createTime(const int32_t val) {
-    createTime = val;
-  }
+  void __set_createTime(const int32_t val);
 
-  void __set_lastAccessTime(const int32_t val) {
-    lastAccessTime = val;
-  }
+  void __set_lastAccessTime(const int32_t val);
 
-  void __set_sd(const StorageDescriptor& val) {
-    sd = val;
-  }
+  void __set_sd(const StorageDescriptor& val);
 
-  void __set_parameters(const std::map<std::string, std::string> & val) {
-    parameters = val;
-  }
+  void __set_parameters(const std::map<std::string, std::string> & val);
 
-  void __set_privileges(const PrincipalPrivilegeSet& val) {
-    privileges = val;
-    __isset.privileges = true;
-  }
+  void __set_privileges(const PrincipalPrivilegeSet& val);
 
   bool operator == (const Partition & rhs) const
   {
@@ -1855,18 +1900,19 @@ class Partition {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const Partition& obj);
 };
 
 void swap(Partition &a, Partition &b);
 
 typedef struct _PartitionWithoutSD__isset {
   _PartitionWithoutSD__isset() : values(false), createTime(false), lastAccessTime(false), relativePath(false), parameters(false), privileges(false) {}
-  bool values;
-  bool createTime;
-  bool lastAccessTime;
-  bool relativePath;
-  bool parameters;
-  bool privileges;
+  bool values :1;
+  bool createTime :1;
+  bool lastAccessTime :1;
+  bool relativePath :1;
+  bool parameters :1;
+  bool privileges :1;
 } _PartitionWithoutSD__isset;
 
 class PartitionWithoutSD {
@@ -1875,11 +1921,12 @@ class PartitionWithoutSD {
   static const char* ascii_fingerprint; // = "D79FA44499888D0E50B5625E0C536DEA";
   static const uint8_t binary_fingerprint[16]; // = {0xD7,0x9F,0xA4,0x44,0x99,0x88,0x8D,0x0E,0x50,0xB5,0x62,0x5E,0x0C,0x53,0x6D,0xEA};
 
+  PartitionWithoutSD(const PartitionWithoutSD&);
+  PartitionWithoutSD& operator=(const PartitionWithoutSD&);
   PartitionWithoutSD() : createTime(0), lastAccessTime(0), relativePath() {
   }
 
-  virtual ~PartitionWithoutSD() throw() {}
-
+  virtual ~PartitionWithoutSD() throw();
   std::vector<std::string>  values;
   int32_t createTime;
   int32_t lastAccessTime;
@@ -1889,30 +1936,17 @@ class PartitionWithoutSD {
 
   _PartitionWithoutSD__isset __isset;
 
-  void __set_values(const std::vector<std::string> & val) {
-    values = val;
-  }
+  void __set_values(const std::vector<std::string> & val);
 
-  void __set_createTime(const int32_t val) {
-    createTime = val;
-  }
+  void __set_createTime(const int32_t val);
 
-  void __set_lastAccessTime(const int32_t val) {
-    lastAccessTime = val;
-  }
+  void __set_lastAccessTime(const int32_t val);
 
-  void __set_relativePath(const std::string& val) {
-    relativePath = val;
-  }
+  void __set_relativePath(const std::string& val);
 
-  void __set_parameters(const std::map<std::string, std::string> & val) {
-    parameters = val;
-  }
+  void __set_parameters(const std::map<std::string, std::string> & val);
 
-  void __set_privileges(const PrincipalPrivilegeSet& val) {
-    privileges = val;
-    __isset.privileges = true;
-  }
+  void __set_privileges(const PrincipalPrivilegeSet& val);
 
   bool operator == (const PartitionWithoutSD & rhs) const
   {
@@ -1941,14 +1975,15 @@ class PartitionWithoutSD {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const PartitionWithoutSD& obj);
 };
 
 void swap(PartitionWithoutSD &a, PartitionWithoutSD &b);
 
 typedef struct _PartitionSpecWithSharedSD__isset {
   _PartitionSpecWithSharedSD__isset() : partitions(false), sd(false) {}
-  bool partitions;
-  bool sd;
+  bool partitions :1;
+  bool sd :1;
 } _PartitionSpecWithSharedSD__isset;
 
 class PartitionSpecWithSharedSD {
@@ -1957,23 +1992,20 @@ class PartitionSpecWithSharedSD {
   static const char* ascii_fingerprint; // = "7BEE9305B42DCD083FF06BEE6DDC61CF";
   static const uint8_t binary_fingerprint[16]; // = {0x7B,0xEE,0x93,0x05,0xB4,0x2D,0xCD,0x08,0x3F,0xF0,0x6B,0xEE,0x6D,0xDC,0x61,0xCF};
 
+  PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD&);
+  PartitionSpecWithSharedSD& operator=(const PartitionSpecWithSharedSD&);
   PartitionSpecWithSharedSD() {
   }
 
-  virtual ~PartitionSpecWithSharedSD() throw() {}
-
+  virtual ~PartitionSpecWithSharedSD() throw();
   std::vector<PartitionWithoutSD>  partitions;
   StorageDescriptor sd;
 
   _PartitionSpecWithSharedSD__isset __isset;
 
-  void __set_partitions(const std::vector<PartitionWithoutSD> & val) {
-    partitions = val;
-  }
+  void __set_partitions(const std::vector<PartitionWithoutSD> & val);
 
-  void __set_sd(const StorageDescriptor& val) {
-    sd = val;
-  }
+  void __set_sd(const StorageDescriptor& val);
 
   bool operator == (const PartitionSpecWithSharedSD & rhs) const
   {
@@ -1992,13 +2024,14 @@ class PartitionSpecWithSharedSD {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const PartitionSpecWithSharedSD& obj);
 };
 
 void swap(PartitionSpecWithSharedSD &a, PartitionSpecWithSharedSD &b);
 
 typedef struct _PartitionListComposingSpec__isset {
   _PartitionListComposingSpec__isset() : partitions(false) {}
-  bool partitions;
+  bool partitions :1;
 } _PartitionListComposingSpec__isset;
 
 class PartitionListComposingSpec {
@@ -2007,18 +2040,17 @@ class PartitionListComposingSpec {
   static const char* ascii_fingerprint; // = "A048235CB9A257C8A74E3691BEFE0674";
   static const uint8_t binary_fingerprint[16]; // = {0xA0,0x48,0x23,0x5C,0xB9,0xA2,0x57,0xC8,0xA7,0x4E,0x36,0x91,0xBE,0xFE,0x06,0x74};
 
+  PartitionListComposingSpec(const PartitionListComposingSpec&);
+  PartitionListComposingSpec& operator=(const PartitionListComposingSpec&);
   PartitionListComposingSpec() {
   }
 
-  virtual ~PartitionListComposingSpec() throw() {}
-
+  virtual ~PartitionListComposingSpec() throw();
   std::vector<Partition>  partitions;
 
   _PartitionListComposingSpec__isset __isset;
 
-  void __set_partitions(const std::vector<Partition> & val) {
-    partitions = val;
-  }
+  void __set_partitions(const std::vector<Partition> & val);
 
   bool operator == (const PartitionListComposingSpec & rhs) const
   {
@@ -2035,17 +2067,18 @@ class PartitionListComposingSpec {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const PartitionListComposingSpec& obj);
 };
 
 void swap(PartitionListComposingSpec &a, PartitionListComposingSpec &b);
 
 typedef struct _PartitionSpec__isset {
   _PartitionSpec__isset() : dbName(false), tableName(false), rootPath(false), sharedSDPartitionSpec(false), partitionList(false) {}
-  bool dbName;
-  bool tableName;
-  bool rootPath;
-  bool sharedSDPartitionSpec;
-  bool partitionList;
+  bool dbName :1;
+  bool tableName :1;
+  bool rootPath :1;
+  bool sharedSDPartitionSpec :1;
+  bool partitionList :1;
 } _PartitionSpec__isset;
 
 class PartitionSpec {
@@ -2054,11 +2087,12 @@ class PartitionSpec {
   static const char* ascii_fingerprint; // = "C3F548C24D072CF6422F25096143E3E8";
   static const uint8_t binary_fingerprint[16]; // = {0xC3,0xF5,0x48,0xC2,0x4D,0x07,0x2C,0xF6,0x42,0x2F,0x25,0x09,0x61,0x43,0xE3,0xE8};
 
+  PartitionSpec(const PartitionSpec&);
+  PartitionSpec& operator=(const PartitionSpec&);
   PartitionSpec() : dbName(), tableName(), rootPath() {
   }
 
-  virtual ~PartitionSpec() throw() {}
-
+  virtual ~PartitionSpec() throw();
   std::string dbName;
   std::string tableName;
   std::string rootPath;
@@ -2067,27 +2101,15 @@ class PartitionSpec {
 
   _PartitionSpec__isset __isset;
 
-  void __set_dbName(const std::string& val) {
-    dbName = val;
-  }
+  void __set_dbName(const std::string& val);
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
-  void __set_rootPath(const std::string& val) {
-    rootPath = val;
-  }
+  void __set_rootPath(const std::string& val);
 
-  void __set_sharedSDPartitionSpec(const PartitionSpecWithSharedSD& val) {
-    sharedSDPartitionSpec = val;
-    __isset.sharedSDPartitionSpec = true;
-  }
+  void __set_sharedSDPartitionSpec(const PartitionSpecWithSharedSD& val);
 
-  void __set_partitionList(const PartitionListComposingSpec& val) {
-    partitionList = val;
-    __isset.partitionList = true;
-  }
+  void __set_partitionList(const PartitionListComposingSpec& val);
 
   bool operator == (const PartitionSpec & rhs) const
   {
@@ -2116,22 +2138,23 @@ class PartitionSpec {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const PartitionSpec& obj);
 };
 
 void swap(PartitionSpec &a, PartitionSpec &b);
 
 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;
-  bool indexHandlerClass;
-  bool dbName;
-  bool origTableName;
-  bool createTime;
-  bool lastAccessTime;
-  bool indexTableName;
-  bool sd;
-  bool parameters;
-  bool deferredRebuild;
+  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 {
@@ -2140,11 +2163,12 @@ class Index {
   static const char* ascii_fingerprint; // = "09EEF655216AC81802850988D6C470A6";
   static const uint8_t binary_fingerprint[16]; // = {0x09,0xEE,0xF6,0x55,0x21,0x6A,0xC8,0x18,0x02,0x85,0x09,0x88,0xD6,0xC4,0x70,0xA6};
 
+  Index(const Index&);
+  Index& operator=(const Index&);
   Index() : indexName(), indexHandlerClass(), dbName(), origTableName(), createTime(0), lastAccessTime(0), indexTableName(), deferredRebuild(0) {
   }
 
-  virtual ~Index() throw() {}
-
+  virtual ~Index() throw();
   std::string indexName;
   std::string indexHandlerClass;
   std::string dbName;
@@ -2158,45 +2182,25 @@ class Index {
 
   _Index__isset __isset;
 
-  void __set_indexName(const std::string& val) {
-    indexName = val;
-  }
+  void __set_indexName(const std::string& val);
 
-  void __set_indexHandlerClass(const std::string& val) {
-    indexHandlerClass = val;
-  }
+  void __set_indexHandlerClass(const std::string& val);
 
-  void __set_dbName(const std::string& val) {
-    dbName = val;
-  }
+  void __set_dbName(const std::string& val);
 
-  void __set_origTableName(const std::string& val) {
-    origTableName = val;
-  }
+  void __set_origTableName(const std::string& val);
 
-  void __set_createTime(const int32_t val) {
-    createTime = val;
-  }
+  void __set_createTime(const int32_t val);
 
-  void __set_lastAccessTime(const int32_t val) {
-    lastAccessTime = val;
-  }
+  void __set_lastAccessTime(const int32_t val);
 
-  void __set_indexTableName(const std::string& val) {
-    indexTableName = val;
-  }
+  void __set_indexTableName(const std::string& val);
 
-  void __set_sd(const StorageDescriptor& val) {
-    sd = val;
-  }
+  void __set_sd(const StorageDescriptor& val);
 
-  void __set_parameters(const std::map<std::string, std::string> & val) {
-    parameters = val;
-  }
+  void __set_parameters(const std::map<std::string, std::string> & val);
 
-  void __set_deferredRebuild(const bool val) {
-    deferredRebuild = val;
-  }
+  void __set_deferredRebuild(const bool val);
 
   bool operator == (const Index & rhs) const
   {
@@ -2231,6 +2235,7 @@ class Index {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const Index& obj);
 };
 
 void swap(Index &a, Index &b);
@@ -2242,26 +2247,21 @@ class BooleanColumnStatsData {
   static const char* ascii_fingerprint; // = "EA2D65F1E0BB78760205682082304B41";
   static const uint8_t binary_fingerprint[16]; // = {0xEA,0x2D,0x65,0xF1,0xE0,0xBB,0x78,0x76,0x02,0x05,0x68,0x20,0x82,0x30,0x4B,0x41};
 
+  BooleanColumnStatsData(const BooleanColumnStatsData&);
+  BooleanColumnStatsData& operator=(const BooleanColumnStatsData&);
   BooleanColumnStatsData() : numTrues(0), numFalses(0), numNulls(0) {
   }
 
-  virtual ~BooleanColumnStatsData() throw() {}
-
+  virtual ~BooleanColumnStatsData() throw();
   int64_t numTrues;
   int64_t numFalses;
   int64_t numNulls;
 
-  void __set_numTrues(const int64_t val) {
-    numTrues = val;
-  }
+  void __set_numTrues(const int64_t val);
 
-  void __set_numFalses(const int64_t val) {
-    numFalses = val;
-  }
+  void __set_numFalses(const int64_t val);
 
-  void __set_numNulls(const int64_t val) {
-    numNulls = val;
-  }
+  void __set_numNulls(const int64_t val);
 
   bool operator == (const BooleanColumnStatsData & rhs) const
   {
@@ -2282,14 +2282,15 @@ class BooleanColumnStatsData {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const BooleanColumnStatsData& obj);
 };
 
 void swap(BooleanColumnStatsData &a, BooleanColumnStatsData &b);
 
 typedef struct _DoubleColumnStatsData__isset {
   _DoubleColumnStatsData__isset() : lowValue(false), highValue(false) {}
-  bool lowValue;
-  bool highValue;
+  bool lowValue :1;
+  bool highValue :1;
 } _DoubleColumnStatsData__isset;
 
 class DoubleColumnStatsData {
@@ -2298,11 +2299,12 @@ class DoubleColumnStatsData {
   static const char* ascii_fingerprint; // = "DA7C011321D74C48396AA002E61A0CBB";
   static const uint8_t binary_fingerprint[16]; // = {0xDA,0x7C,0x01,0x13,0x21,0xD7,0x4C,0x48,0x39,0x6A,0xA0,0x02,0xE6,0x1A,0x0C,0xBB};
 
+  DoubleColumnStatsData(const DoubleColumnStatsData&);
+  DoubleColumnStatsData& operator=(const DoubleColumnStatsData&);
   DoubleColumnStatsData() : lowValue(0), highValue(0), numNulls(0), numDVs(0) {
   }
 
-  virtual ~DoubleColumnStatsData() throw() {}
-
+  virtual ~DoubleColumnStatsData() throw();
   double lowValue;
   double highValue;
   int64_t numNulls;
@@ -2310,23 +2312,13 @@ class DoubleColumnStatsData {
 
   _DoubleColumnStatsData__isset __isset;
 
-  void __set_lowValue(const double val) {
-    lowValue = val;
-    __isset.lowValue = true;
-  }
+  void __set_lowValue(const double val);
 
-  void __set_highValue(const double val) {
-    highValue = val;
-    __isset.highValue = true;
-  }
+  void __set_highValue(const double val);
 
-  void __set_numNulls(const int64_t val) {
-    numNulls = val;
-  }
+  void __set_numNulls(const int64_t val);
 
-  void __set_numDVs(const int64_t val) {
-    numDVs = val;
-  }
+  void __set_numDVs(const int64_t val);
 
   bool operator == (const DoubleColumnStatsData & rhs) const
   {
@@ -2353,14 +2345,15 @@ class DoubleColumnStatsData {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const DoubleColumnStatsData& obj);
 };
 
 void swap(DoubleColumnStatsData &a, DoubleColumnStatsData &b);
 
 typedef struct _LongColumnStatsData__isset {
   _LongColumnStatsData__isset() : lowValue(false), highValue(false) {}
-  bool lowValue;
-  bool highValue;
+  bool lowValue :1;
+  bool highValue :1;
 } _LongColumnStatsData__isset;
 
 class LongColumnStatsData {
@@ -2369,11 +2362,12 @@ class LongColumnStatsData {
   static const char* ascii_fingerprint; // = "E685FC220B24E3B8B93604790DCB9AEA";
   static const uint8_t binary_fingerprint[16]; // = {0xE6,0x85,0xFC,0x22,0x0B,0x24,0xE3,0xB8,0xB9,0x36,0x04,0x79,0x0D,0xCB,0x9A,0xEA};
 
+  LongColumnStatsData(const LongColumnStatsData&);
+  LongColumnStatsData& operator=(const LongColumnStatsData&);
   LongColumnStatsData() : lowValue(0), highValue(0), numNulls(0), numDVs(0) {
   }
 
-  virtual ~LongColumnStatsData() throw() {}
-
+  virtual ~LongColumnStatsData() throw();
   int64_t lowValue;
   int64_t highValue;
   int64_t numNulls;
@@ -2381,23 +2375,13 @@ class LongColumnStatsData {
 
   _LongColumnStatsData__isset __isset;
 
-  void __set_lowValue(const int64_t val) {
-    lowValue = val;
-    __isset.lowValue = true;
-  }
+  void __set_lowValue(const int64_t val);
 
-  void __set_highValue(const int64_t val) {
-    highValue = val;
-    __isset.highValue = true;
-  }
+  void __set_highValue(const int64_t val);
 
-  void __set_numNulls(const int64_t val) {
-    numNulls = val;
-  }
+  void __set_numNulls(const int64_t val);
 
-  void __set_numDVs(const int64_t val) {
-    numDVs = val;
-  }
+  void __set_numDVs(const int64_t val);
 
   bool operator == (const LongColumnStatsData & rhs) const
   {
@@ -2424,6 +2408,7 @@ class LongColumnStatsData {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const LongColumnStatsData& obj);
 };
 
 void swap(LongColumnStatsData &a, LongColumnStatsData &b);
@@ -2435,31 +2420,24 @@ class StringColumnStatsData {
   static const char* ascii_fingerprint; // = "D017B08C3DF12C3AB98788B2E67DAAB3";
   static const uint8_t binary_fingerprint[16]; // = {0xD0,0x17,0xB0,0x8C,0x3D,0xF1,0x2C,0x3A,0xB9,0x87,0x88,0xB2,0xE6,0x7D,0xAA,0xB3};
 
+  StringColumnStatsData(const StringColumnStatsData&);
+  StringColumnStatsData& operator=(const StringColumnStatsData&);
   StringColumnStatsData() : maxColLen(0), avgColLen(0), numNulls(0), numDVs(0) {
   }
 
-  virtual ~StringColumnStatsData() throw() {}
-
+  virtual ~StringColumnStatsData() throw();
   int64_t maxColLen;
   double avgColLen;
   int64_t numNulls;
   int64_t numDVs;
 
-  void __set_maxColLen(const int64_t val) {
-    maxColLen = val;
-  }
+  void __set_maxColLen(const int64_t val);
 
-  void __set_avgColLen(const double val) {
-    avgColLen = val;
-  }
+  void __set_avgColLen(const double val);
 
-  void __set_numNulls(const int64_t val) {
-    numNulls = val;
-  }
+  void __set_numNulls(const int64_t val);
 
-  void __set_numDVs(const int64_t val) {
-    numDVs = val;
-  }
+  void __set_numDVs(const int64_t val);
 
   bool operator == (const StringColumnStatsData & rhs) const
   {
@@ -2482,6 +2460,7 @@ class StringColumnStatsData {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const StringColumnStatsData& obj);
 };
 
 void swap(StringColumnStatsData &a, StringColumnStatsData &b);
@@ -2493,26 +2472,21 @@ class BinaryColumnStatsData {
   static const char* ascii_fingerprint; // = "22B0CB67183FCDB945892B9974518D06";
   static const uint8_t binary_fingerprint[16]; // = {0x22,0xB0,0xCB,0x67,0x18,0x3F,0xCD,0xB9,0x45,0x89,0x2B,0x99,0x74,0x51,0x8D,0x06};
 
+  BinaryColumnStatsData(const BinaryColumnStatsData&);
+  BinaryColumnStatsData& operator=(const BinaryColumnStatsData&);
   BinaryColumnStatsData() : maxColLen(0), avgColLen(0), numNulls(0) {
   }
 
-  virtual ~BinaryColumnStatsData() throw() {}
-
+  virtual ~BinaryColumnStatsData() throw();
   int64_t maxColLen;
   double avgColLen;
   int64_t numNulls;
 
-  void __set_maxColLen(const int64_t val) {
-    maxColLen = val;
-  }
+  void __set_maxColLen(const int64_t val);
 
-  void __set_avgColLen(const double val) {
-    avgColLen = val;
-  }
+  void __set_avgColLen(const double val);
 
-  void __set_numNulls(const int64_t val) {
-    numNulls = val;
-  }
+  void __set_numNulls(const int64_t val);
 
   bool operator == (const BinaryColumnStatsData & rhs) const
   {
@@ -2533,6 +2507,7 @@ class BinaryColumnStatsData {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const BinaryColumnStatsData& obj);
 };
 
 void swap(BinaryColumnStatsData &a, BinaryColumnStatsData &b);
@@ -2544,21 +2519,18 @@ class Decimal {
   static const char* ascii_fingerprint; // = "C4DDF6759F9B17C5C380806CE743DE8E";
   static const uint8_t binary_fingerprint[16]; // = {0xC4,0xDD,0xF6,0x75,0x9F,0x9B,0x17,0xC5,0xC3,0x80,0x80,0x6C,0xE7,0x43,0xDE,0x8E};
 
+  Decimal(const Decimal&);
+  Decimal& operator=(const Decimal&);
   Decimal() : unscaled(), scale(0) {
   }
 
-  virtual ~Decimal() throw() {}
-
+  virtual ~Decimal() throw();
   std::string unscaled;
   int16_t scale;
 
-  void __set_unscaled(const std::string& val) {
-    unscaled = val;
-  }
+  void __set_unscaled(const std::string& val);
 
-  void __set_scale(const int16_t val) {
-    scale = val;
-  }
+  void __set_scale(const int16_t val);
 
   bool operator == (const Decimal & rhs) const
   {
@@ -2577,14 +2549,15 @@ class Decimal {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const Decimal& obj);
 };
 
 void swap(Decimal &a, Decimal &b);
 
 typedef struct _DecimalColumnStatsData__isset {
   _DecimalColumnStatsData__isset() : lowValue(false), highValue(false) {}
-  bool lowValue;
-  bool highValue;
+  bool lowValue :1;
+  bool highValue :1;
 } _DecimalColumnStatsData__isset;
 
 class DecimalColumnStatsData {
@@ -2593,11 +2566,12 @@ class DecimalColumnStatsData {
   static const char* ascii_fingerprint; // = "B6D47E7A28922BFA93FE05E9F1B04748";
   static const uint8_t binary_fingerprint[16]; // = {0xB6,0xD4,0x7E,0x7A,0x28,0x92,0x2B,0xFA,0x93,0xFE,0x05,0xE9,0xF1,0xB0,0x47,0x48};
 
+  DecimalColumnStatsData(const DecimalColumnStatsData&);
+  DecimalColumnStatsData& operator=(const DecimalColumnStatsData&);
   DecimalColumnStatsData() : numNulls(0), numDVs(0) {
   }
 
-  virtual ~DecimalColumnStatsData() throw() {}
-
+  virtual ~DecimalColumnStatsData() throw();
   Decimal lowValue;
   Decimal highValue;
   int64_t numNulls;
@@ -2605,23 +2579,13 @@ class DecimalColumnStatsData {
 
   _DecimalColumnStatsData__isset __isset;
 
-  void __set_lowValue(const Decimal& val) {
-    lowValue = val;
-    __isset.lowValue = true;
-  }
+  void __set_lowValue(const Decimal& val);
 
-  void __set_highValue(const Decimal& val) {
-    highValue = val;
-    __isset.highValue = true;
-  }
+  void __set_highValue(const Decimal& val);
 
-  void __set_numNulls(const int64_t val) {
-    numNulls = val;
-  }
+  void __set_numNulls(const int64_t val);
 
-  void __set_numDVs(const int64_t val) {
-    numDVs = val;
-  }
+  void __set_numDVs(const int64_t val);
 
   bool operator == (const DecimalColumnStatsData & rhs) const
   {
@@ -2648,6 +2612,7 @@ class DecimalColumnStatsData {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const DecimalColumnStatsData& obj);
 };
 
 void swap(DecimalColumnStatsData &a, DecimalColumnStatsData &b);
@@ -2659,16 +2624,15 @@ class Date {
   static const char* ascii_fingerprint; // = "56A59CE7FFAF82BCA8A19FAACDE4FB75";
   static const uint8_t binary_fingerprint[16]; // = {0x56,0xA5,0x9C,0xE7,0xFF,0xAF,0x82,0xBC,0xA8,0xA1,0x9F,0xAA,0xCD,0xE4,0xFB,0x75};
 
+  Date(const Date&);
+  Date& operator=(const Date&);
   Date() : daysSinceEpoch(0) {
   }
 
-  virtual ~Date() throw() {}
-
+  virtual ~Date() throw();
   int64_t daysSinceEpoch;
 
-  void __set_daysSinceEpoch(const int64_t val) {
-    daysSinceEpoch = val;
-  }
+  void __set_daysSinceEpoch(const int64_t val);
 
   bool operator == (const Date & rhs) const
   {
@@ -2685,14 +2649,15 @@ class Date {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const Date& obj);
 };
 
 void swap(Date &a, Date &b);
 
 typedef struct _DateColumnStatsData__isset {
   _DateColumnStatsData__isset() : lowValue(false), highValue(false) {}
-  bool lowValue;
-  bool highValue;
+  bool lowValue :1;
+  bool highValue :1;
 } _DateColumnStatsData__isset;
 
 class DateColumnStatsData {
@@ -2701,11 +2666,12 @@ class DateColumnStatsData {
   static const char* ascii_fingerprint; // = "D0719F3BBA8248297BB5287552897F59";
   static const uint8_t binary_fingerprint[16]; // = {0xD0,0x71,0x9F,0x3B,0xBA,0x82,0x48,0x29,0x7B,0xB5,0x28,0x75,0x52,0x89,0x7F,0x59};
 
+  DateColumnStatsData(const DateColumnStatsData&);
+  DateColumnStatsData& operator=(const DateColumnStatsData&);
   DateColumnStatsData() : numNulls(0), numDVs(0) {
   }
 
-  virtual ~DateColumnStatsData() throw() {}
-
+  virtual ~DateColumnStatsData() throw();
   Date lowValue;
   Date highValue;
   int64_t numNulls;
@@ -2713,23 +2679,13 @@ class DateColumnStatsData {
 
   _DateColumnStatsData__isset __isset;
 
-  void __set_lowValue(const Date& val) {
-    lowValue = val;
-    __isset.lowValue = true;
-  }
+  void __set_lowValue(const Date& val);
 
-  void __set_highValue(const Date& val) {
-    highValue = val;
-    __isset.highValue = true;
-  }
+  void __set_highValue(const Date& val);
 
-  void __set_numNulls(const int64_t val) {
-    numNulls = val;
-  }
+  void __set_numNulls(const int64_t val);
 
-  void __set_numDVs(const int64_t val) {
-    numDVs = val;
-  }
+  void __set_numDVs(const int64_t val);
 
   bool operator == (const DateColumnStatsData & rhs) const
   {
@@ -2756,19 +2712,20 @@ class DateColumnStatsData {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const DateColumnStatsData& obj);
 };
 
 void swap(DateColumnStatsData &a, DateColumnStatsData &b);
 
 typedef struct _ColumnStatisticsData__isset {
   _ColumnStatisticsData__isset() : booleanStats(false), longStats(false), doubleStats(false), stringStats(false), binaryStats(false), decimalStats(false), dateStats(false) {}
-  bool booleanStats;
-  bool longStats;
-  bool doubleStats;
-  bool stringStats;
-  bool binaryStats;
-  bool decimalStats;
-  bool dateStats;
+  bool booleanStats :1;
+  bool longStats :1;
+  bool doubleStats :1;
+  bool stringStats :1;
+  bool binaryStats :1;
+  bool decimalStats :1;
+  bool dateStats :1;
 } _ColumnStatisticsData__isset;
 
 class ColumnStatisticsData {
@@ -2777,11 +2734,12 @@ class ColumnStatisticsData {
   static const char* ascii_fingerprint; // = "15E449CA15A23E37F2D54C31ACA52106";
   static const uint8_t binary_fingerprint[16]; // = {0x15,0xE4,0x49,0xCA,0x15,0xA2,0x3E,0x37,0xF2,0xD5,0x4C,0x31,0xAC,0xA5,0x21,0x06};
 
+  ColumnStatisticsData(const ColumnStatisticsData&);
+  ColumnStatisticsData& operator=(const ColumnStatisticsData&);
   ColumnStatisticsData() {
   }
 
-  virtual ~ColumnStatisticsData() throw() {}
-
+  virtual ~ColumnStatisticsData() throw();
   BooleanColumnStatsData booleanStats;
   LongColumnStatsData longStats;
   DoubleColumnStatsData doubleStats;
@@ -2792,33 +2750,19 @@ class ColumnStatisticsData {
 
   _ColumnStatisticsData__isset __isset;
 
-  void __set_booleanStats(const BooleanColumnStatsData& val) {
-    booleanStats = val;
-  }
+  void __set_booleanStats(const BooleanColumnStatsData& val);
 
-  void __set_longStats(const LongColumnStatsData& val) {
-    longStats = val;
-  }
+  void __set_longStats(const LongColumnStatsData& val);
 
-  void __set_doubleStats(const DoubleColumnStatsData& val) {
-    doubleStats = val;
-  }
+  void __set_doubleStats(const DoubleColumnStatsData& val);
 
-  void __set_stringStats(const StringColumnStatsData& val) {
-    stringStats = val;
-  }
+  void __set_stringStats(const StringColumnStatsData& val);
 
-  void __set_binaryStats(const BinaryColumnStatsData& val) {
-    binaryStats = val;
-  }
+  void __set_binaryStats(const BinaryColumnStatsData& val);
 
-  void __set_decimalStats(const DecimalColumnStatsData& val) {
-    decimalStats = val;
-  }
+  void __set_decimalStats(const DecimalColumnStatsData& val);
 
-  void __set_dateStats(const DateColumnStatsData& val) {
-    dateStats = val;
-  }
+  void __set_dateStats(const DateColumnStatsData& val);
 
   bool operator == (const ColumnStatisticsData & rhs) const
   {
@@ -2847,6 +2791,7 @@ class ColumnStatisticsData {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const ColumnStatisticsData& obj);
 };
 
 void swap(ColumnStatisticsData &a, ColumnStatisticsData &b);
@@ -2858,26 +2803,21 @@ class ColumnStatisticsObj {
   static const char* ascii_fingerprint; // = "A82BA819C9FFEDDEBC0D50F6F4E46534";
   static const uint8_t binary_fingerprint[16]; // = {0xA8,0x2B,0xA8,0x19,0xC9,0xFF,0xED,0xDE,0xBC,0x0D,0x50,0xF6,0xF4,0xE4,0x65,0x34};
 
+  ColumnStatisticsObj(const ColumnStatisticsObj&);
+  ColumnStatisticsObj& operator=(const ColumnStatisticsObj&);
   ColumnStatisticsObj() : colName(), colType() {
   }
 
-  virtual ~ColumnStatisticsObj() throw() {}
-
+  virtual ~ColumnStatisticsObj() throw();
   std::string colName;
   std::string colType;
   ColumnStatisticsData statsData;
 
-  void __set_colName(const std::string& val) {
-    colName = val;
-  }
+  void __set_colName(const std::string& val);
 
-  void __set_colType(const std::string& val) {
-    colType = val;
-  }
+  void __set_colType(const std::string& val);
 
-  void __set_statsData(const ColumnStatisticsData& val) {
-    statsData = val;
-  }
+  void __set_statsData(const ColumnStatisticsData& val);
 
   bool operator == (const ColumnStatisticsObj & rhs) const
   {
@@ -2898,14 +2838,15 @@ class ColumnStatisticsObj {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const ColumnStatisticsObj& obj);
 };
 
 void swap(ColumnStatisticsObj &a, ColumnStatisticsObj &b);
 
 typedef struct _ColumnStatisticsDesc__isset {
   _ColumnStatisticsDesc__isset() : partName(false), lastAnalyzed(false) {}
-  bool partName;
-  bool lastAnalyzed;
+  bool partName :1;
+  bool lastAnalyzed :1;
 } _ColumnStatisticsDesc__isset;
 
 class ColumnStatisticsDesc {
@@ -2914,11 +2855,12 @@ class ColumnStatisticsDesc {
   static const char* ascii_fingerprint; // = "261759FF6F8FAB53F941453007FE18CB";
   static const uint8_t binary_fingerprint[16]; // = {0x26,0x17,0x59,0xFF,0x6F,0x8F,0xAB,0x53,0xF9,0x41,0x45,0x30,0x07,0xFE,0x18,0xCB};
 
+  ColumnStatisticsDesc(const ColumnStatisticsDesc&);
+  ColumnStatisticsDesc& operator=(const ColumnStatisticsDesc&);
   ColumnStatisticsDesc() : isTblLevel(0), dbName(), tableName(), partName(), lastAnalyzed(0) {
   }
 
-  virtual ~ColumnStatisticsDesc() throw() {}
-
+  virtual ~ColumnStatisticsDesc() throw();
   bool isTblLevel;
   std::string dbName;
   std::string tableName;
@@ -2927,27 +2869,15 @@ class ColumnStatisticsDesc {
 
   _ColumnStatisticsDesc__isset __isset;
 
-  void __set_isTblLevel(const bool val) {
-    isTblLevel = val;
-  }
+  void __set_isTblLevel(const bool val);
 
-  void __set_dbName(const std::string& val) {
-    dbName = val;
-  }
+  void __set_dbName(const std::string& val);
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
-  void __set_partName(const std::string& val) {
-    partName = val;
-    __isset.partName = true;
-  }
+  void __set_partName(const std::string& val);
 
-  void __set_lastAnalyzed(const int64_t val) {
-    lastAnalyzed = val;
-    __isset.lastAnalyzed = true;
-  }
+  void __set_lastAnalyzed(const int64_t val);
 
   bool operator == (const ColumnStatisticsDesc & rhs) const
   {
@@ -2976,6 +2906,7 @@ class ColumnStatisticsDesc {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const ColumnStatisticsDesc& obj);
 };
 
 void swap(ColumnStatisticsDesc &a, ColumnStatisticsDesc &b);
@@ -2987,21 +2918,18 @@ class ColumnStatistics {
   static const char* ascii_fingerprint; // = "8A64D0A67FFD3A372726A320B3913D5A";
   static const uint8_t binary_fingerprint[16]; // = {0x8A,0x64,0xD0,0xA6,0x7F,0xFD,0x3A,0x37,0x27,0x26,0xA3,0x20,0xB3,0x91,0x3D,0x5A};
 
+  ColumnStatistics(const ColumnStatistics&);
+  ColumnStatistics& operator=(const ColumnStatistics&);
   ColumnStatistics() {
   }
 
-  virtual ~ColumnStatistics() throw() {}
-
+  virtual ~ColumnStatistics() throw();
   ColumnStatisticsDesc statsDesc;
   std::vector<ColumnStatisticsObj>  statsObj;
 
-  void __set_statsDesc(const ColumnStatisticsDesc& val) {
-    statsDesc = val;
-  }
+  void __set_statsDesc(const ColumnStatisticsDesc& val);
 
-  void __set_statsObj(const std::vector<ColumnStatisticsObj> & val) {
-    statsObj = val;
-  }
+  void __set_statsObj(const std::vector<ColumnStatisticsObj> & val);
 
   bool operator == (const ColumnStatistics & rhs) const
   {
@@ -3020,6 +2948,7 @@ class ColumnStatistics {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const ColumnStatistics& obj);
 };
 
 void swap(ColumnStatistics &a, ColumnStatistics &b);
@@ -3031,21 +2960,18 @@ class AggrStats {
   static const char* ascii_fingerprint; // = "1FC765A3AB2954591C14B0D946778213";
   static const uint8_t binary_fingerprint[16]; // = {0x1F,0xC7,0x65,0xA3,0xAB,0x29,0x54,0x59,0x1C,0x14,0xB0,0xD9,0x46,0x77,0x82,0x13};
 
+  AggrStats(const AggrStats&);
+  AggrStats& operator=(const AggrStats&);
   AggrStats() : partsFound(0) {
   }
 
-  virtual ~AggrStats() throw() {}
-
+  virtual ~AggrStats() throw();
   std::vector<ColumnStatisticsObj>  colStats;
   int64_t partsFound;
 
-  void __set_colStats(const std::vector<ColumnStatisticsObj> & val) {
-    colStats = val;
-  }
+  void __set_colStats(const std::vector<ColumnStatisticsObj> & val);
 
-  void __set_partsFound(const int64_t val) {
-    partsFound = val;
-  }
+  void __set_partsFound(const int64_t val);
 
   bool operator == (const AggrStats & rhs) const
   {
@@ -3064,6 +2990,7 @@ class AggrStats {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const AggrStats& obj);
 };
 
 void swap(AggrStats &a, AggrStats &b);
@@ -3075,16 +3002,15 @@ class SetPartitionsStatsRequest {
   static const char* ascii_fingerprint; // = "8BCBF2CE9E942D0FB7D8F4ED57D8DC27";
   static const uint8_t binary_fingerprint[16]; // = {0x8B,0xCB,0xF2,0xCE,0x9E,0x94,0x2D,0x0F,0xB7,0xD8,0xF4,0xED,0x57,0xD8,0xDC,0x27};
 
+  SetPartitionsStatsRequest(const SetPartitionsStatsRequest&);
+  SetPartitionsStatsRequest& operator=(const SetPartitionsStatsRequest&);
   SetPartitionsStatsRequest() {
   }
 
-  virtual ~SetPartitionsStatsRequest() throw() {}
-
+  virtual ~SetPartitionsStatsRequest() throw();
   std::vector<ColumnStatistics>  colStats;
 
-  void __set_colStats(const std::vector<ColumnStatistics> & val) {
-    colStats = val;
-  }
+  void __set_colStats(const std::vector<ColumnStatistics> & val);
 
   bool operator == (const SetPartitionsStatsRequest & rhs) const
   {
@@ -3101,14 +3027,15 @@ class SetPartitionsStatsRequest {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostr

<TRUNCATED>