/**
 * Autogenerated by Thrift
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 */
#ifndef hive_metastore_TYPES_H
#define hive_metastore_TYPES_H

#include <Thrift.h>
#include <TApplicationException.h>
#include <protocol/TProtocol.h>
#include <transport/TTransport.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
  };
};

struct PrincipalType {
  enum type {
    USER = 1,
    ROLE = 2,
    GROUP = 3
  };
};

typedef struct _Version__isset {
  _Version__isset() : version(false), comments(false) {}
  bool version;
  bool comments;
} _Version__isset;

class Version {
 public:

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

  virtual ~Version() throw() {}

  std::string version;
  std::string comments;

  _Version__isset __isset;

  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;

};

typedef struct _FieldSchema__isset {
  _FieldSchema__isset() : name(false), type(false), comment(false) {}
  bool name;
  bool type;
  bool comment;
} _FieldSchema__isset;

class FieldSchema {
 public:

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

  virtual ~FieldSchema() throw() {}

  std::string name;
  std::string type;
  std::string comment;

  _FieldSchema__isset __isset;

  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;

};

typedef struct _Type__isset {
  _Type__isset() : name(false), type1(false), type2(false), fields(false) {}
  bool name;
  bool type1;
  bool type2;
  bool fields;
} _Type__isset;

class Type {
 public:

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

  virtual ~Type() throw() {}

  std::string name;
  std::string type1;
  std::string type2;
  std::vector<FieldSchema>  fields;

  _Type__isset __isset;

  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;

};

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;
} _HiveObjectRef__isset;

class HiveObjectRef {
 public:

  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() : dbName(""), objectName(""), columnName("") {
  }

  virtual ~HiveObjectRef() throw() {}

  HiveObjectType::type objectType;
  std::string dbName;
  std::string objectName;
  std::vector<std::string>  partValues;
  std::string columnName;

  _HiveObjectRef__isset __isset;

  bool operator == (const HiveObjectRef & rhs) const
  {
    if (!(objectType == rhs.objectType))
      return false;
    if (!(dbName == rhs.dbName))
      return false;
    if (!(objectName == rhs.objectName))
      return false;
    if (!(partValues == rhs.partValues))
      return false;
    if (!(columnName == rhs.columnName))
      return false;
    return true;
  }
  bool operator != (const HiveObjectRef &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const HiveObjectRef & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

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;
} _PrivilegeGrantInfo__isset;

class PrivilegeGrantInfo {
 public:

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

  virtual ~PrivilegeGrantInfo() throw() {}

  std::string privilege;
  int32_t createTime;
  std::string grantor;
  PrincipalType::type grantorType;
  bool grantOption;

  _PrivilegeGrantInfo__isset __isset;

  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;

};

typedef struct _HiveObjectPrivilege__isset {
  _HiveObjectPrivilege__isset() : hiveObject(false), principalName(false), principalType(false), grantInfo(false) {}
  bool hiveObject;
  bool principalName;
  bool principalType;
  bool grantInfo;
} _HiveObjectPrivilege__isset;

class HiveObjectPrivilege {
 public:

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

  virtual ~HiveObjectPrivilege() throw() {}

  HiveObjectRef hiveObject;
  std::string principalName;
  PrincipalType::type principalType;
  PrivilegeGrantInfo grantInfo;

  _HiveObjectPrivilege__isset __isset;

  bool operator == (const HiveObjectPrivilege & rhs) const
  {
    if (!(hiveObject == rhs.hiveObject))
      return false;
    if (!(principalName == rhs.principalName))
      return false;
    if (!(principalType == rhs.principalType))
      return false;
    if (!(grantInfo == rhs.grantInfo))
      return false;
    return true;
  }
  bool operator != (const HiveObjectPrivilege &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const HiveObjectPrivilege & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _PrivilegeBag__isset {
  _PrivilegeBag__isset() : privileges(false) {}
  bool privileges;
} _PrivilegeBag__isset;

class PrivilegeBag {
 public:

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

  virtual ~PrivilegeBag() throw() {}

  std::vector<HiveObjectPrivilege>  privileges;

  _PrivilegeBag__isset __isset;

  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;

};

typedef struct _PrincipalPrivilegeSet__isset {
  _PrincipalPrivilegeSet__isset() : userPrivileges(false), groupPrivileges(false), rolePrivileges(false) {}
  bool userPrivileges;
  bool groupPrivileges;
  bool rolePrivileges;
} _PrincipalPrivilegeSet__isset;

class PrincipalPrivilegeSet {
 public:

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

  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;

  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;

};

typedef struct _Role__isset {
  _Role__isset() : roleName(false), createTime(false), ownerName(false) {}
  bool roleName;
  bool createTime;
  bool ownerName;
} _Role__isset;

class Role {
 public:

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

  virtual ~Role() throw() {}

  std::string roleName;
  int32_t createTime;
  std::string ownerName;

  _Role__isset __isset;

  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;

};

typedef struct _Database__isset {
  _Database__isset() : name(false), description(false), locationUri(false), parameters(false), privileges(false) {}
  bool name;
  bool description;
  bool locationUri;
  bool parameters;
  bool privileges;
} _Database__isset;

class Database {
 public:

  static const char* ascii_fingerprint; // = "213967572143E49C9F1A23F7A866E2F5";
  static const uint8_t binary_fingerprint[16]; // = {0x21,0x39,0x67,0x57,0x21,0x43,0xE4,0x9C,0x9F,0x1A,0x23,0xF7,0xA8,0x66,0xE2,0xF5};

  Database() : name(""), description(""), locationUri("") {
  }

  virtual ~Database() throw() {}

  std::string name;
  std::string description;
  std::string locationUri;
  std::map<std::string, std::string>  parameters;
  PrincipalPrivilegeSet privileges;

  _Database__isset __isset;

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

};

typedef struct _SerDeInfo__isset {
  _SerDeInfo__isset() : name(false), serializationLib(false), parameters(false) {}
  bool name;
  bool serializationLib;
  bool parameters;
} _SerDeInfo__isset;

class SerDeInfo {
 public:

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

  virtual ~SerDeInfo() throw() {}

  std::string name;
  std::string serializationLib;
  std::map<std::string, std::string>  parameters;

  _SerDeInfo__isset __isset;

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

  bool operator < (const SerDeInfo & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Order__isset {
  _Order__isset() : col(false), order(false) {}
  bool col;
  bool order;
} _Order__isset;

class Order {
 public:

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

  virtual ~Order() throw() {}

  std::string col;
  int32_t order;

  _Order__isset __isset;

  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;

};

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) {}
  bool cols;
  bool location;
  bool inputFormat;
  bool outputFormat;
  bool compressed;
  bool numBuckets;
  bool serdeInfo;
  bool bucketCols;
  bool sortCols;
  bool parameters;
} _StorageDescriptor__isset;

class StorageDescriptor {
 public:

  static const char* ascii_fingerprint; // = "11E4CE18F895C13812C853DFDCD1293F";
  static const uint8_t binary_fingerprint[16]; // = {0x11,0xE4,0xCE,0x18,0xF8,0x95,0xC1,0x38,0x12,0xC8,0x53,0xDF,0xDC,0xD1,0x29,0x3F};

  StorageDescriptor() : location(""), inputFormat(""), outputFormat(""), compressed(0), numBuckets(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;

  _StorageDescriptor__isset __isset;

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

};

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

class Table {
 public:

  static const char* ascii_fingerprint; // = "26BE788C09746068A2616712C9262900";
  static const uint8_t binary_fingerprint[16]; // = {0x26,0xBE,0x78,0x8C,0x09,0x74,0x60,0x68,0xA2,0x61,0x67,0x12,0xC9,0x26,0x29,0x00};

  Table() : tableName(""), dbName(""), owner(""), createTime(0), lastAccessTime(0), retention(0), viewOriginalText(""), viewExpandedText(""), tableType("") {
  }

  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;

  _Table__isset __isset;

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

};

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;
} _Partition__isset;

class Partition {
 public:

  static const char* ascii_fingerprint; // = "F480E1D1B8AEBDDB37F8E180C0F07395";
  static const uint8_t binary_fingerprint[16]; // = {0xF4,0x80,0xE1,0xD1,0xB8,0xAE,0xBD,0xDB,0x37,0xF8,0xE1,0x80,0xC0,0xF0,0x73,0x95};

  Partition() : dbName(""), tableName(""), createTime(0), lastAccessTime(0) {
  }

  virtual ~Partition() throw() {}

  std::vector<std::string>  values;
  std::string dbName;
  std::string tableName;
  int32_t createTime;
  int32_t lastAccessTime;
  StorageDescriptor sd;
  std::map<std::string, std::string>  parameters;
  PrincipalPrivilegeSet privileges;

  _Partition__isset __isset;

  bool operator == (const Partition & rhs) const
  {
    if (!(values == rhs.values))
      return false;
    if (!(dbName == rhs.dbName))
      return false;
    if (!(tableName == rhs.tableName))
      return false;
    if (!(createTime == rhs.createTime))
      return false;
    if (!(lastAccessTime == rhs.lastAccessTime))
      return false;
    if (!(sd == rhs.sd))
      return false;
    if (!(parameters == rhs.parameters))
      return false;
    if (__isset.privileges != rhs.__isset.privileges)
      return false;
    else if (__isset.privileges && !(privileges == rhs.privileges))
      return false;
    return true;
  }
  bool operator != (const Partition &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Partition & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

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;
} _Index__isset;

class Index {
 public:

  static const char* ascii_fingerprint; // = "5FEE4F7E28935B644F207D74459F6A29";
  static const uint8_t binary_fingerprint[16]; // = {0x5F,0xEE,0x4F,0x7E,0x28,0x93,0x5B,0x64,0x4F,0x20,0x7D,0x74,0x45,0x9F,0x6A,0x29};

  Index() : indexName(""), indexHandlerClass(""), dbName(""), origTableName(""), createTime(0), lastAccessTime(0), indexTableName(""), deferredRebuild(0) {
  }

  virtual ~Index() throw() {}

  std::string indexName;
  std::string indexHandlerClass;
  std::string dbName;
  std::string origTableName;
  int32_t createTime;
  int32_t lastAccessTime;
  std::string indexTableName;
  StorageDescriptor sd;
  std::map<std::string, std::string>  parameters;
  bool deferredRebuild;

  _Index__isset __isset;

  bool operator == (const Index & rhs) const
  {
    if (!(indexName == rhs.indexName))
      return false;
    if (!(indexHandlerClass == rhs.indexHandlerClass))
      return false;
    if (!(dbName == rhs.dbName))
      return false;
    if (!(origTableName == rhs.origTableName))
      return false;
    if (!(createTime == rhs.createTime))
      return false;
    if (!(lastAccessTime == rhs.lastAccessTime))
      return false;
    if (!(indexTableName == rhs.indexTableName))
      return false;
    if (!(sd == rhs.sd))
      return false;
    if (!(parameters == rhs.parameters))
      return false;
    if (!(deferredRebuild == rhs.deferredRebuild))
      return false;
    return true;
  }
  bool operator != (const Index &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Index & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Schema__isset {
  _Schema__isset() : fieldSchemas(false), properties(false) {}
  bool fieldSchemas;
  bool properties;
} _Schema__isset;

class Schema {
 public:

  static const char* ascii_fingerprint; // = "5CFEE46C975F4E2368D905109B8E3B5B";
  static const uint8_t binary_fingerprint[16]; // = {0x5C,0xFE,0xE4,0x6C,0x97,0x5F,0x4E,0x23,0x68,0xD9,0x05,0x10,0x9B,0x8E,0x3B,0x5B};

  Schema() {
  }

  virtual ~Schema() throw() {}

  std::vector<FieldSchema>  fieldSchemas;
  std::map<std::string, std::string>  properties;

  _Schema__isset __isset;

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

  bool operator < (const Schema & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _MetaException__isset {
  _MetaException__isset() : message(false) {}
  bool message;
} _MetaException__isset;

class MetaException : public ::apache::thrift::TException {
 public:

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

  MetaException() : message("") {
  }

  virtual ~MetaException() throw() {}

  std::string message;

  _MetaException__isset __isset;

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

  bool operator < (const MetaException & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _UnknownTableException__isset {
  _UnknownTableException__isset() : message(false) {}
  bool message;
} _UnknownTableException__isset;

class UnknownTableException : public ::apache::thrift::TException {
 public:

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

  UnknownTableException() : message("") {
  }

  virtual ~UnknownTableException() throw() {}

  std::string message;

  _UnknownTableException__isset __isset;

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

  bool operator < (const UnknownTableException & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _UnknownDBException__isset {
  _UnknownDBException__isset() : message(false) {}
  bool message;
} _UnknownDBException__isset;

class UnknownDBException : public ::apache::thrift::TException {
 public:

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

  UnknownDBException() : message("") {
  }

  virtual ~UnknownDBException() throw() {}

  std::string message;

  _UnknownDBException__isset __isset;

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

  bool operator < (const UnknownDBException & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _AlreadyExistsException__isset {
  _AlreadyExistsException__isset() : message(false) {}
  bool message;
} _AlreadyExistsException__isset;

class AlreadyExistsException : public ::apache::thrift::TException {
 public:

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

  AlreadyExistsException() : message("") {
  }

  virtual ~AlreadyExistsException() throw() {}

  std::string message;

  _AlreadyExistsException__isset __isset;

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

  bool operator < (const AlreadyExistsException & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _InvalidObjectException__isset {
  _InvalidObjectException__isset() : message(false) {}
  bool message;
} _InvalidObjectException__isset;

class InvalidObjectException : public ::apache::thrift::TException {
 public:

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

  InvalidObjectException() : message("") {
  }

  virtual ~InvalidObjectException() throw() {}

  std::string message;

  _InvalidObjectException__isset __isset;

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

  bool operator < (const InvalidObjectException & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _NoSuchObjectException__isset {
  _NoSuchObjectException__isset() : message(false) {}
  bool message;
} _NoSuchObjectException__isset;

class NoSuchObjectException : public ::apache::thrift::TException {
 public:

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

  NoSuchObjectException() : message("") {
  }

  virtual ~NoSuchObjectException() throw() {}

  std::string message;

  _NoSuchObjectException__isset __isset;

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

  bool operator < (const NoSuchObjectException & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IndexAlreadyExistsException__isset {
  _IndexAlreadyExistsException__isset() : message(false) {}
  bool message;
} _IndexAlreadyExistsException__isset;

class IndexAlreadyExistsException : public ::apache::thrift::TException {
 public:

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

  IndexAlreadyExistsException() : message("") {
  }

  virtual ~IndexAlreadyExistsException() throw() {}

  std::string message;

  _IndexAlreadyExistsException__isset __isset;

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

  bool operator < (const IndexAlreadyExistsException & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _InvalidOperationException__isset {
  _InvalidOperationException__isset() : message(false) {}
  bool message;
} _InvalidOperationException__isset;

class InvalidOperationException : public ::apache::thrift::TException {
 public:

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

  InvalidOperationException() : message("") {
  }

  virtual ~InvalidOperationException() throw() {}

  std::string message;

  _InvalidOperationException__isset __isset;

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

  bool operator < (const InvalidOperationException & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _ConfigValSecurityException__isset {
  _ConfigValSecurityException__isset() : message(false) {}
  bool message;
} _ConfigValSecurityException__isset;

class ConfigValSecurityException : public ::apache::thrift::TException {
 public:

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

  ConfigValSecurityException() : message("") {
  }

  virtual ~ConfigValSecurityException() throw() {}

  std::string message;

  _ConfigValSecurityException__isset __isset;

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

  bool operator < (const ConfigValSecurityException & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

}}} // namespace

#endif