PageRenderTime 97ms CodeModel.GetById 19ms app.highlight 69ms RepoModel.GetById 1ms app.codeStats 1ms

/tags/release-0.1-rc2/hive/external/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h

#
C Header | 1277 lines | 978 code | 294 blank | 5 comment | 286 complexity | 44eb0233db6932dc1aed4de7e0396a0b MD5 | raw file
   1/**
   2 * Autogenerated by Thrift
   3 *
   4 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
   5 */
   6#ifndef hive_metastore_TYPES_H
   7#define hive_metastore_TYPES_H
   8
   9#include <Thrift.h>
  10#include <TApplicationException.h>
  11#include <protocol/TProtocol.h>
  12#include <transport/TTransport.h>
  13
  14#include "fb303_types.h"
  15
  16
  17namespace Apache { namespace Hadoop { namespace Hive {
  18
  19struct HiveObjectType {
  20  enum type {
  21    GLOBAL = 1,
  22    DATABASE = 2,
  23    TABLE = 3,
  24    PARTITION = 4,
  25    COLUMN = 5
  26  };
  27};
  28
  29struct PrincipalType {
  30  enum type {
  31    USER = 1,
  32    ROLE = 2,
  33    GROUP = 3
  34  };
  35};
  36
  37typedef struct _Version__isset {
  38  _Version__isset() : version(false), comments(false) {}
  39  bool version;
  40  bool comments;
  41} _Version__isset;
  42
  43class Version {
  44 public:
  45
  46  static const char* ascii_fingerprint; // = "07A9615F837F7D0A952B595DD3020972";
  47  static const uint8_t binary_fingerprint[16]; // = {0x07,0xA9,0x61,0x5F,0x83,0x7F,0x7D,0x0A,0x95,0x2B,0x59,0x5D,0xD3,0x02,0x09,0x72};
  48
  49  Version() : version(""), comments("") {
  50  }
  51
  52  virtual ~Version() throw() {}
  53
  54  std::string version;
  55  std::string comments;
  56
  57  _Version__isset __isset;
  58
  59  bool operator == (const Version & rhs) const
  60  {
  61    if (!(version == rhs.version))
  62      return false;
  63    if (!(comments == rhs.comments))
  64      return false;
  65    return true;
  66  }
  67  bool operator != (const Version &rhs) const {
  68    return !(*this == rhs);
  69  }
  70
  71  bool operator < (const Version & ) const;
  72
  73  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  74  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  75
  76};
  77
  78typedef struct _FieldSchema__isset {
  79  _FieldSchema__isset() : name(false), type(false), comment(false) {}
  80  bool name;
  81  bool type;
  82  bool comment;
  83} _FieldSchema__isset;
  84
  85class FieldSchema {
  86 public:
  87
  88  static const char* ascii_fingerprint; // = "AB879940BD15B6B25691265F7384B271";
  89  static const uint8_t binary_fingerprint[16]; // = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71};
  90
  91  FieldSchema() : name(""), type(""), comment("") {
  92  }
  93
  94  virtual ~FieldSchema() throw() {}
  95
  96  std::string name;
  97  std::string type;
  98  std::string comment;
  99
 100  _FieldSchema__isset __isset;
 101
 102  bool operator == (const FieldSchema & rhs) const
 103  {
 104    if (!(name == rhs.name))
 105      return false;
 106    if (!(type == rhs.type))
 107      return false;
 108    if (!(comment == rhs.comment))
 109      return false;
 110    return true;
 111  }
 112  bool operator != (const FieldSchema &rhs) const {
 113    return !(*this == rhs);
 114  }
 115
 116  bool operator < (const FieldSchema & ) const;
 117
 118  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 119  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 120
 121};
 122
 123typedef struct _Type__isset {
 124  _Type__isset() : name(false), type1(false), type2(false), fields(false) {}
 125  bool name;
 126  bool type1;
 127  bool type2;
 128  bool fields;
 129} _Type__isset;
 130
 131class Type {
 132 public:
 133
 134  static const char* ascii_fingerprint; // = "20DF02DE523C27F7066C7BD4D9120842";
 135  static const uint8_t binary_fingerprint[16]; // = {0x20,0xDF,0x02,0xDE,0x52,0x3C,0x27,0xF7,0x06,0x6C,0x7B,0xD4,0xD9,0x12,0x08,0x42};
 136
 137  Type() : name(""), type1(""), type2("") {
 138  }
 139
 140  virtual ~Type() throw() {}
 141
 142  std::string name;
 143  std::string type1;
 144  std::string type2;
 145  std::vector<FieldSchema>  fields;
 146
 147  _Type__isset __isset;
 148
 149  bool operator == (const Type & rhs) const
 150  {
 151    if (!(name == rhs.name))
 152      return false;
 153    if (__isset.type1 != rhs.__isset.type1)
 154      return false;
 155    else if (__isset.type1 && !(type1 == rhs.type1))
 156      return false;
 157    if (__isset.type2 != rhs.__isset.type2)
 158      return false;
 159    else if (__isset.type2 && !(type2 == rhs.type2))
 160      return false;
 161    if (__isset.fields != rhs.__isset.fields)
 162      return false;
 163    else if (__isset.fields && !(fields == rhs.fields))
 164      return false;
 165    return true;
 166  }
 167  bool operator != (const Type &rhs) const {
 168    return !(*this == rhs);
 169  }
 170
 171  bool operator < (const Type & ) const;
 172
 173  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 174  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 175
 176};
 177
 178typedef struct _HiveObjectRef__isset {
 179  _HiveObjectRef__isset() : objectType(false), dbName(false), objectName(false), partValues(false), columnName(false) {}
 180  bool objectType;
 181  bool dbName;
 182  bool objectName;
 183  bool partValues;
 184  bool columnName;
 185} _HiveObjectRef__isset;
 186
 187class HiveObjectRef {
 188 public:
 189
 190  static const char* ascii_fingerprint; // = "205CD8311CF3AA9EC161BAEF8D7C933C";
 191  static const uint8_t binary_fingerprint[16]; // = {0x20,0x5C,0xD8,0x31,0x1C,0xF3,0xAA,0x9E,0xC1,0x61,0xBA,0xEF,0x8D,0x7C,0x93,0x3C};
 192
 193  HiveObjectRef() : dbName(""), objectName(""), columnName("") {
 194  }
 195
 196  virtual ~HiveObjectRef() throw() {}
 197
 198  HiveObjectType::type objectType;
 199  std::string dbName;
 200  std::string objectName;
 201  std::vector<std::string>  partValues;
 202  std::string columnName;
 203
 204  _HiveObjectRef__isset __isset;
 205
 206  bool operator == (const HiveObjectRef & rhs) const
 207  {
 208    if (!(objectType == rhs.objectType))
 209      return false;
 210    if (!(dbName == rhs.dbName))
 211      return false;
 212    if (!(objectName == rhs.objectName))
 213      return false;
 214    if (!(partValues == rhs.partValues))
 215      return false;
 216    if (!(columnName == rhs.columnName))
 217      return false;
 218    return true;
 219  }
 220  bool operator != (const HiveObjectRef &rhs) const {
 221    return !(*this == rhs);
 222  }
 223
 224  bool operator < (const HiveObjectRef & ) const;
 225
 226  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 227  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 228
 229};
 230
 231typedef struct _PrivilegeGrantInfo__isset {
 232  _PrivilegeGrantInfo__isset() : privilege(false), createTime(false), grantor(false), grantorType(false), grantOption(false) {}
 233  bool privilege;
 234  bool createTime;
 235  bool grantor;
 236  bool grantorType;
 237  bool grantOption;
 238} _PrivilegeGrantInfo__isset;
 239
 240class PrivilegeGrantInfo {
 241 public:
 242
 243  static const char* ascii_fingerprint; // = "A58923AF7294BE492D6F90E07E8CEE1F";
 244  static const uint8_t binary_fingerprint[16]; // = {0xA5,0x89,0x23,0xAF,0x72,0x94,0xBE,0x49,0x2D,0x6F,0x90,0xE0,0x7E,0x8C,0xEE,0x1F};
 245
 246  PrivilegeGrantInfo() : privilege(""), createTime(0), grantor(""), grantOption(0) {
 247  }
 248
 249  virtual ~PrivilegeGrantInfo() throw() {}
 250
 251  std::string privilege;
 252  int32_t createTime;
 253  std::string grantor;
 254  PrincipalType::type grantorType;
 255  bool grantOption;
 256
 257  _PrivilegeGrantInfo__isset __isset;
 258
 259  bool operator == (const PrivilegeGrantInfo & rhs) const
 260  {
 261    if (!(privilege == rhs.privilege))
 262      return false;
 263    if (!(createTime == rhs.createTime))
 264      return false;
 265    if (!(grantor == rhs.grantor))
 266      return false;
 267    if (!(grantorType == rhs.grantorType))
 268      return false;
 269    if (!(grantOption == rhs.grantOption))
 270      return false;
 271    return true;
 272  }
 273  bool operator != (const PrivilegeGrantInfo &rhs) const {
 274    return !(*this == rhs);
 275  }
 276
 277  bool operator < (const PrivilegeGrantInfo & ) const;
 278
 279  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 280  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 281
 282};
 283
 284typedef struct _HiveObjectPrivilege__isset {
 285  _HiveObjectPrivilege__isset() : hiveObject(false), principalName(false), principalType(false), grantInfo(false) {}
 286  bool hiveObject;
 287  bool principalName;
 288  bool principalType;
 289  bool grantInfo;
 290} _HiveObjectPrivilege__isset;
 291
 292class HiveObjectPrivilege {
 293 public:
 294
 295  static const char* ascii_fingerprint; // = "83D71969B23BD853E29DBA9D43B29AF8";
 296  static const uint8_t binary_fingerprint[16]; // = {0x83,0xD7,0x19,0x69,0xB2,0x3B,0xD8,0x53,0xE2,0x9D,0xBA,0x9D,0x43,0xB2,0x9A,0xF8};
 297
 298  HiveObjectPrivilege() : principalName("") {
 299  }
 300
 301  virtual ~HiveObjectPrivilege() throw() {}
 302
 303  HiveObjectRef hiveObject;
 304  std::string principalName;
 305  PrincipalType::type principalType;
 306  PrivilegeGrantInfo grantInfo;
 307
 308  _HiveObjectPrivilege__isset __isset;
 309
 310  bool operator == (const HiveObjectPrivilege & rhs) const
 311  {
 312    if (!(hiveObject == rhs.hiveObject))
 313      return false;
 314    if (!(principalName == rhs.principalName))
 315      return false;
 316    if (!(principalType == rhs.principalType))
 317      return false;
 318    if (!(grantInfo == rhs.grantInfo))
 319      return false;
 320    return true;
 321  }
 322  bool operator != (const HiveObjectPrivilege &rhs) const {
 323    return !(*this == rhs);
 324  }
 325
 326  bool operator < (const HiveObjectPrivilege & ) const;
 327
 328  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 329  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 330
 331};
 332
 333typedef struct _PrivilegeBag__isset {
 334  _PrivilegeBag__isset() : privileges(false) {}
 335  bool privileges;
 336} _PrivilegeBag__isset;
 337
 338class PrivilegeBag {
 339 public:
 340
 341  static const char* ascii_fingerprint; // = "BB89E4701B7B709B046A74C90B1147F2";
 342  static const uint8_t binary_fingerprint[16]; // = {0xBB,0x89,0xE4,0x70,0x1B,0x7B,0x70,0x9B,0x04,0x6A,0x74,0xC9,0x0B,0x11,0x47,0xF2};
 343
 344  PrivilegeBag() {
 345  }
 346
 347  virtual ~PrivilegeBag() throw() {}
 348
 349  std::vector<HiveObjectPrivilege>  privileges;
 350
 351  _PrivilegeBag__isset __isset;
 352
 353  bool operator == (const PrivilegeBag & rhs) const
 354  {
 355    if (!(privileges == rhs.privileges))
 356      return false;
 357    return true;
 358  }
 359  bool operator != (const PrivilegeBag &rhs) const {
 360    return !(*this == rhs);
 361  }
 362
 363  bool operator < (const PrivilegeBag & ) const;
 364
 365  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 366  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 367
 368};
 369
 370typedef struct _PrincipalPrivilegeSet__isset {
 371  _PrincipalPrivilegeSet__isset() : userPrivileges(false), groupPrivileges(false), rolePrivileges(false) {}
 372  bool userPrivileges;
 373  bool groupPrivileges;
 374  bool rolePrivileges;
 375} _PrincipalPrivilegeSet__isset;
 376
 377class PrincipalPrivilegeSet {
 378 public:
 379
 380  static const char* ascii_fingerprint; // = "08F75D2533906EA87BE34EA640856683";
 381  static const uint8_t binary_fingerprint[16]; // = {0x08,0xF7,0x5D,0x25,0x33,0x90,0x6E,0xA8,0x7B,0xE3,0x4E,0xA6,0x40,0x85,0x66,0x83};
 382
 383  PrincipalPrivilegeSet() {
 384  }
 385
 386  virtual ~PrincipalPrivilegeSet() throw() {}
 387
 388  std::map<std::string, std::vector<PrivilegeGrantInfo> >  userPrivileges;
 389  std::map<std::string, std::vector<PrivilegeGrantInfo> >  groupPrivileges;
 390  std::map<std::string, std::vector<PrivilegeGrantInfo> >  rolePrivileges;
 391
 392  _PrincipalPrivilegeSet__isset __isset;
 393
 394  bool operator == (const PrincipalPrivilegeSet & rhs) const
 395  {
 396    if (!(userPrivileges == rhs.userPrivileges))
 397      return false;
 398    if (!(groupPrivileges == rhs.groupPrivileges))
 399      return false;
 400    if (!(rolePrivileges == rhs.rolePrivileges))
 401      return false;
 402    return true;
 403  }
 404  bool operator != (const PrincipalPrivilegeSet &rhs) const {
 405    return !(*this == rhs);
 406  }
 407
 408  bool operator < (const PrincipalPrivilegeSet & ) const;
 409
 410  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 411  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 412
 413};
 414
 415typedef struct _Role__isset {
 416  _Role__isset() : roleName(false), createTime(false), ownerName(false) {}
 417  bool roleName;
 418  bool createTime;
 419  bool ownerName;
 420} _Role__isset;
 421
 422class Role {
 423 public:
 424
 425  static const char* ascii_fingerprint; // = "70563A0628F75DF9555F4D24690B1E26";
 426  static const uint8_t binary_fingerprint[16]; // = {0x70,0x56,0x3A,0x06,0x28,0xF7,0x5D,0xF9,0x55,0x5F,0x4D,0x24,0x69,0x0B,0x1E,0x26};
 427
 428  Role() : roleName(""), createTime(0), ownerName("") {
 429  }
 430
 431  virtual ~Role() throw() {}
 432
 433  std::string roleName;
 434  int32_t createTime;
 435  std::string ownerName;
 436
 437  _Role__isset __isset;
 438
 439  bool operator == (const Role & rhs) const
 440  {
 441    if (!(roleName == rhs.roleName))
 442      return false;
 443    if (!(createTime == rhs.createTime))
 444      return false;
 445    if (!(ownerName == rhs.ownerName))
 446      return false;
 447    return true;
 448  }
 449  bool operator != (const Role &rhs) const {
 450    return !(*this == rhs);
 451  }
 452
 453  bool operator < (const Role & ) const;
 454
 455  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 456  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 457
 458};
 459
 460typedef struct _Database__isset {
 461  _Database__isset() : name(false), description(false), locationUri(false), parameters(false), privileges(false) {}
 462  bool name;
 463  bool description;
 464  bool locationUri;
 465  bool parameters;
 466  bool privileges;
 467} _Database__isset;
 468
 469class Database {
 470 public:
 471
 472  static const char* ascii_fingerprint; // = "213967572143E49C9F1A23F7A866E2F5";
 473  static const uint8_t binary_fingerprint[16]; // = {0x21,0x39,0x67,0x57,0x21,0x43,0xE4,0x9C,0x9F,0x1A,0x23,0xF7,0xA8,0x66,0xE2,0xF5};
 474
 475  Database() : name(""), description(""), locationUri("") {
 476  }
 477
 478  virtual ~Database() throw() {}
 479
 480  std::string name;
 481  std::string description;
 482  std::string locationUri;
 483  std::map<std::string, std::string>  parameters;
 484  PrincipalPrivilegeSet privileges;
 485
 486  _Database__isset __isset;
 487
 488  bool operator == (const Database & rhs) const
 489  {
 490    if (!(name == rhs.name))
 491      return false;
 492    if (!(description == rhs.description))
 493      return false;
 494    if (!(locationUri == rhs.locationUri))
 495      return false;
 496    if (!(parameters == rhs.parameters))
 497      return false;
 498    if (__isset.privileges != rhs.__isset.privileges)
 499      return false;
 500    else if (__isset.privileges && !(privileges == rhs.privileges))
 501      return false;
 502    return true;
 503  }
 504  bool operator != (const Database &rhs) const {
 505    return !(*this == rhs);
 506  }
 507
 508  bool operator < (const Database & ) const;
 509
 510  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 511  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 512
 513};
 514
 515typedef struct _SerDeInfo__isset {
 516  _SerDeInfo__isset() : name(false), serializationLib(false), parameters(false) {}
 517  bool name;
 518  bool serializationLib;
 519  bool parameters;
 520} _SerDeInfo__isset;
 521
 522class SerDeInfo {
 523 public:
 524
 525  static const char* ascii_fingerprint; // = "B1021C32A35A2AEFCD2F57A5424159A7";
 526  static const uint8_t binary_fingerprint[16]; // = {0xB1,0x02,0x1C,0x32,0xA3,0x5A,0x2A,0xEF,0xCD,0x2F,0x57,0xA5,0x42,0x41,0x59,0xA7};
 527
 528  SerDeInfo() : name(""), serializationLib("") {
 529  }
 530
 531  virtual ~SerDeInfo() throw() {}
 532
 533  std::string name;
 534  std::string serializationLib;
 535  std::map<std::string, std::string>  parameters;
 536
 537  _SerDeInfo__isset __isset;
 538
 539  bool operator == (const SerDeInfo & rhs) const
 540  {
 541    if (!(name == rhs.name))
 542      return false;
 543    if (!(serializationLib == rhs.serializationLib))
 544      return false;
 545    if (!(parameters == rhs.parameters))
 546      return false;
 547    return true;
 548  }
 549  bool operator != (const SerDeInfo &rhs) const {
 550    return !(*this == rhs);
 551  }
 552
 553  bool operator < (const SerDeInfo & ) const;
 554
 555  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 556  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 557
 558};
 559
 560typedef struct _Order__isset {
 561  _Order__isset() : col(false), order(false) {}
 562  bool col;
 563  bool order;
 564} _Order__isset;
 565
 566class Order {
 567 public:
 568
 569  static const char* ascii_fingerprint; // = "EEBC915CE44901401D881E6091423036";
 570  static const uint8_t binary_fingerprint[16]; // = {0xEE,0xBC,0x91,0x5C,0xE4,0x49,0x01,0x40,0x1D,0x88,0x1E,0x60,0x91,0x42,0x30,0x36};
 571
 572  Order() : col(""), order(0) {
 573  }
 574
 575  virtual ~Order() throw() {}
 576
 577  std::string col;
 578  int32_t order;
 579
 580  _Order__isset __isset;
 581
 582  bool operator == (const Order & rhs) const
 583  {
 584    if (!(col == rhs.col))
 585      return false;
 586    if (!(order == rhs.order))
 587      return false;
 588    return true;
 589  }
 590  bool operator != (const Order &rhs) const {
 591    return !(*this == rhs);
 592  }
 593
 594  bool operator < (const Order & ) const;
 595
 596  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 597  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 598
 599};
 600
 601typedef struct _StorageDescriptor__isset {
 602  _StorageDescriptor__isset() : cols(false), location(false), inputFormat(false), outputFormat(false), compressed(false), numBuckets(false), serdeInfo(false), bucketCols(false), sortCols(false), parameters(false) {}
 603  bool cols;
 604  bool location;
 605  bool inputFormat;
 606  bool outputFormat;
 607  bool compressed;
 608  bool numBuckets;
 609  bool serdeInfo;
 610  bool bucketCols;
 611  bool sortCols;
 612  bool parameters;
 613} _StorageDescriptor__isset;
 614
 615class StorageDescriptor {
 616 public:
 617
 618  static const char* ascii_fingerprint; // = "11E4CE18F895C13812C853DFDCD1293F";
 619  static const uint8_t binary_fingerprint[16]; // = {0x11,0xE4,0xCE,0x18,0xF8,0x95,0xC1,0x38,0x12,0xC8,0x53,0xDF,0xDC,0xD1,0x29,0x3F};
 620
 621  StorageDescriptor() : location(""), inputFormat(""), outputFormat(""), compressed(0), numBuckets(0) {
 622  }
 623
 624  virtual ~StorageDescriptor() throw() {}
 625
 626  std::vector<FieldSchema>  cols;
 627  std::string location;
 628  std::string inputFormat;
 629  std::string outputFormat;
 630  bool compressed;
 631  int32_t numBuckets;
 632  SerDeInfo serdeInfo;
 633  std::vector<std::string>  bucketCols;
 634  std::vector<Order>  sortCols;
 635  std::map<std::string, std::string>  parameters;
 636
 637  _StorageDescriptor__isset __isset;
 638
 639  bool operator == (const StorageDescriptor & rhs) const
 640  {
 641    if (!(cols == rhs.cols))
 642      return false;
 643    if (!(location == rhs.location))
 644      return false;
 645    if (!(inputFormat == rhs.inputFormat))
 646      return false;
 647    if (!(outputFormat == rhs.outputFormat))
 648      return false;
 649    if (!(compressed == rhs.compressed))
 650      return false;
 651    if (!(numBuckets == rhs.numBuckets))
 652      return false;
 653    if (!(serdeInfo == rhs.serdeInfo))
 654      return false;
 655    if (!(bucketCols == rhs.bucketCols))
 656      return false;
 657    if (!(sortCols == rhs.sortCols))
 658      return false;
 659    if (!(parameters == rhs.parameters))
 660      return false;
 661    return true;
 662  }
 663  bool operator != (const StorageDescriptor &rhs) const {
 664    return !(*this == rhs);
 665  }
 666
 667  bool operator < (const StorageDescriptor & ) const;
 668
 669  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 670  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 671
 672};
 673
 674typedef struct _Table__isset {
 675  _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) {}
 676  bool tableName;
 677  bool dbName;
 678  bool owner;
 679  bool createTime;
 680  bool lastAccessTime;
 681  bool retention;
 682  bool sd;
 683  bool partitionKeys;
 684  bool parameters;
 685  bool viewOriginalText;
 686  bool viewExpandedText;
 687  bool tableType;
 688  bool privileges;
 689} _Table__isset;
 690
 691class Table {
 692 public:
 693
 694  static const char* ascii_fingerprint; // = "26BE788C09746068A2616712C9262900";
 695  static const uint8_t binary_fingerprint[16]; // = {0x26,0xBE,0x78,0x8C,0x09,0x74,0x60,0x68,0xA2,0x61,0x67,0x12,0xC9,0x26,0x29,0x00};
 696
 697  Table() : tableName(""), dbName(""), owner(""), createTime(0), lastAccessTime(0), retention(0), viewOriginalText(""), viewExpandedText(""), tableType("") {
 698  }
 699
 700  virtual ~Table() throw() {}
 701
 702  std::string tableName;
 703  std::string dbName;
 704  std::string owner;
 705  int32_t createTime;
 706  int32_t lastAccessTime;
 707  int32_t retention;
 708  StorageDescriptor sd;
 709  std::vector<FieldSchema>  partitionKeys;
 710  std::map<std::string, std::string>  parameters;
 711  std::string viewOriginalText;
 712  std::string viewExpandedText;
 713  std::string tableType;
 714  PrincipalPrivilegeSet privileges;
 715
 716  _Table__isset __isset;
 717
 718  bool operator == (const Table & rhs) const
 719  {
 720    if (!(tableName == rhs.tableName))
 721      return false;
 722    if (!(dbName == rhs.dbName))
 723      return false;
 724    if (!(owner == rhs.owner))
 725      return false;
 726    if (!(createTime == rhs.createTime))
 727      return false;
 728    if (!(lastAccessTime == rhs.lastAccessTime))
 729      return false;
 730    if (!(retention == rhs.retention))
 731      return false;
 732    if (!(sd == rhs.sd))
 733      return false;
 734    if (!(partitionKeys == rhs.partitionKeys))
 735      return false;
 736    if (!(parameters == rhs.parameters))
 737      return false;
 738    if (!(viewOriginalText == rhs.viewOriginalText))
 739      return false;
 740    if (!(viewExpandedText == rhs.viewExpandedText))
 741      return false;
 742    if (!(tableType == rhs.tableType))
 743      return false;
 744    if (__isset.privileges != rhs.__isset.privileges)
 745      return false;
 746    else if (__isset.privileges && !(privileges == rhs.privileges))
 747      return false;
 748    return true;
 749  }
 750  bool operator != (const Table &rhs) const {
 751    return !(*this == rhs);
 752  }
 753
 754  bool operator < (const Table & ) const;
 755
 756  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 757  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 758
 759};
 760
 761typedef struct _Partition__isset {
 762  _Partition__isset() : values(false), dbName(false), tableName(false), createTime(false), lastAccessTime(false), sd(false), parameters(false), privileges(false) {}
 763  bool values;
 764  bool dbName;
 765  bool tableName;
 766  bool createTime;
 767  bool lastAccessTime;
 768  bool sd;
 769  bool parameters;
 770  bool privileges;
 771} _Partition__isset;
 772
 773class Partition {
 774 public:
 775
 776  static const char* ascii_fingerprint; // = "F480E1D1B8AEBDDB37F8E180C0F07395";
 777  static const uint8_t binary_fingerprint[16]; // = {0xF4,0x80,0xE1,0xD1,0xB8,0xAE,0xBD,0xDB,0x37,0xF8,0xE1,0x80,0xC0,0xF0,0x73,0x95};
 778
 779  Partition() : dbName(""), tableName(""), createTime(0), lastAccessTime(0) {
 780  }
 781
 782  virtual ~Partition() throw() {}
 783
 784  std::vector<std::string>  values;
 785  std::string dbName;
 786  std::string tableName;
 787  int32_t createTime;
 788  int32_t lastAccessTime;
 789  StorageDescriptor sd;
 790  std::map<std::string, std::string>  parameters;
 791  PrincipalPrivilegeSet privileges;
 792
 793  _Partition__isset __isset;
 794
 795  bool operator == (const Partition & rhs) const
 796  {
 797    if (!(values == rhs.values))
 798      return false;
 799    if (!(dbName == rhs.dbName))
 800      return false;
 801    if (!(tableName == rhs.tableName))
 802      return false;
 803    if (!(createTime == rhs.createTime))
 804      return false;
 805    if (!(lastAccessTime == rhs.lastAccessTime))
 806      return false;
 807    if (!(sd == rhs.sd))
 808      return false;
 809    if (!(parameters == rhs.parameters))
 810      return false;
 811    if (__isset.privileges != rhs.__isset.privileges)
 812      return false;
 813    else if (__isset.privileges && !(privileges == rhs.privileges))
 814      return false;
 815    return true;
 816  }
 817  bool operator != (const Partition &rhs) const {
 818    return !(*this == rhs);
 819  }
 820
 821  bool operator < (const Partition & ) const;
 822
 823  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 824  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 825
 826};
 827
 828typedef struct _Index__isset {
 829  _Index__isset() : indexName(false), indexHandlerClass(false), dbName(false), origTableName(false), createTime(false), lastAccessTime(false), indexTableName(false), sd(false), parameters(false), deferredRebuild(false) {}
 830  bool indexName;
 831  bool indexHandlerClass;
 832  bool dbName;
 833  bool origTableName;
 834  bool createTime;
 835  bool lastAccessTime;
 836  bool indexTableName;
 837  bool sd;
 838  bool parameters;
 839  bool deferredRebuild;
 840} _Index__isset;
 841
 842class Index {
 843 public:
 844
 845  static const char* ascii_fingerprint; // = "5FEE4F7E28935B644F207D74459F6A29";
 846  static const uint8_t binary_fingerprint[16]; // = {0x5F,0xEE,0x4F,0x7E,0x28,0x93,0x5B,0x64,0x4F,0x20,0x7D,0x74,0x45,0x9F,0x6A,0x29};
 847
 848  Index() : indexName(""), indexHandlerClass(""), dbName(""), origTableName(""), createTime(0), lastAccessTime(0), indexTableName(""), deferredRebuild(0) {
 849  }
 850
 851  virtual ~Index() throw() {}
 852
 853  std::string indexName;
 854  std::string indexHandlerClass;
 855  std::string dbName;
 856  std::string origTableName;
 857  int32_t createTime;
 858  int32_t lastAccessTime;
 859  std::string indexTableName;
 860  StorageDescriptor sd;
 861  std::map<std::string, std::string>  parameters;
 862  bool deferredRebuild;
 863
 864  _Index__isset __isset;
 865
 866  bool operator == (const Index & rhs) const
 867  {
 868    if (!(indexName == rhs.indexName))
 869      return false;
 870    if (!(indexHandlerClass == rhs.indexHandlerClass))
 871      return false;
 872    if (!(dbName == rhs.dbName))
 873      return false;
 874    if (!(origTableName == rhs.origTableName))
 875      return false;
 876    if (!(createTime == rhs.createTime))
 877      return false;
 878    if (!(lastAccessTime == rhs.lastAccessTime))
 879      return false;
 880    if (!(indexTableName == rhs.indexTableName))
 881      return false;
 882    if (!(sd == rhs.sd))
 883      return false;
 884    if (!(parameters == rhs.parameters))
 885      return false;
 886    if (!(deferredRebuild == rhs.deferredRebuild))
 887      return false;
 888    return true;
 889  }
 890  bool operator != (const Index &rhs) const {
 891    return !(*this == rhs);
 892  }
 893
 894  bool operator < (const Index & ) const;
 895
 896  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 897  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 898
 899};
 900
 901typedef struct _Schema__isset {
 902  _Schema__isset() : fieldSchemas(false), properties(false) {}
 903  bool fieldSchemas;
 904  bool properties;
 905} _Schema__isset;
 906
 907class Schema {
 908 public:
 909
 910  static const char* ascii_fingerprint; // = "5CFEE46C975F4E2368D905109B8E3B5B";
 911  static const uint8_t binary_fingerprint[16]; // = {0x5C,0xFE,0xE4,0x6C,0x97,0x5F,0x4E,0x23,0x68,0xD9,0x05,0x10,0x9B,0x8E,0x3B,0x5B};
 912
 913  Schema() {
 914  }
 915
 916  virtual ~Schema() throw() {}
 917
 918  std::vector<FieldSchema>  fieldSchemas;
 919  std::map<std::string, std::string>  properties;
 920
 921  _Schema__isset __isset;
 922
 923  bool operator == (const Schema & rhs) const
 924  {
 925    if (!(fieldSchemas == rhs.fieldSchemas))
 926      return false;
 927    if (!(properties == rhs.properties))
 928      return false;
 929    return true;
 930  }
 931  bool operator != (const Schema &rhs) const {
 932    return !(*this == rhs);
 933  }
 934
 935  bool operator < (const Schema & ) const;
 936
 937  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 938  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 939
 940};
 941
 942typedef struct _MetaException__isset {
 943  _MetaException__isset() : message(false) {}
 944  bool message;
 945} _MetaException__isset;
 946
 947class MetaException : public ::apache::thrift::TException {
 948 public:
 949
 950  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
 951  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
 952
 953  MetaException() : message("") {
 954  }
 955
 956  virtual ~MetaException() throw() {}
 957
 958  std::string message;
 959
 960  _MetaException__isset __isset;
 961
 962  bool operator == (const MetaException & rhs) const
 963  {
 964    if (!(message == rhs.message))
 965      return false;
 966    return true;
 967  }
 968  bool operator != (const MetaException &rhs) const {
 969    return !(*this == rhs);
 970  }
 971
 972  bool operator < (const MetaException & ) const;
 973
 974  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 975  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 976
 977};
 978
 979typedef struct _UnknownTableException__isset {
 980  _UnknownTableException__isset() : message(false) {}
 981  bool message;
 982} _UnknownTableException__isset;
 983
 984class UnknownTableException : public ::apache::thrift::TException {
 985 public:
 986
 987  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
 988  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
 989
 990  UnknownTableException() : message("") {
 991  }
 992
 993  virtual ~UnknownTableException() throw() {}
 994
 995  std::string message;
 996
 997  _UnknownTableException__isset __isset;
 998
 999  bool operator == (const UnknownTableException & rhs) const
1000  {
1001    if (!(message == rhs.message))
1002      return false;
1003    return true;
1004  }
1005  bool operator != (const UnknownTableException &rhs) const {
1006    return !(*this == rhs);
1007  }
1008
1009  bool operator < (const UnknownTableException & ) const;
1010
1011  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1012  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1013
1014};
1015
1016typedef struct _UnknownDBException__isset {
1017  _UnknownDBException__isset() : message(false) {}
1018  bool message;
1019} _UnknownDBException__isset;
1020
1021class UnknownDBException : public ::apache::thrift::TException {
1022 public:
1023
1024  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
1025  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
1026
1027  UnknownDBException() : message("") {
1028  }
1029
1030  virtual ~UnknownDBException() throw() {}
1031
1032  std::string message;
1033
1034  _UnknownDBException__isset __isset;
1035
1036  bool operator == (const UnknownDBException & rhs) const
1037  {
1038    if (!(message == rhs.message))
1039      return false;
1040    return true;
1041  }
1042  bool operator != (const UnknownDBException &rhs) const {
1043    return !(*this == rhs);
1044  }
1045
1046  bool operator < (const UnknownDBException & ) const;
1047
1048  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1049  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1050
1051};
1052
1053typedef struct _AlreadyExistsException__isset {
1054  _AlreadyExistsException__isset() : message(false) {}
1055  bool message;
1056} _AlreadyExistsException__isset;
1057
1058class AlreadyExistsException : public ::apache::thrift::TException {
1059 public:
1060
1061  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
1062  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
1063
1064  AlreadyExistsException() : message("") {
1065  }
1066
1067  virtual ~AlreadyExistsException() throw() {}
1068
1069  std::string message;
1070
1071  _AlreadyExistsException__isset __isset;
1072
1073  bool operator == (const AlreadyExistsException & rhs) const
1074  {
1075    if (!(message == rhs.message))
1076      return false;
1077    return true;
1078  }
1079  bool operator != (const AlreadyExistsException &rhs) const {
1080    return !(*this == rhs);
1081  }
1082
1083  bool operator < (const AlreadyExistsException & ) const;
1084
1085  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1086  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1087
1088};
1089
1090typedef struct _InvalidObjectException__isset {
1091  _InvalidObjectException__isset() : message(false) {}
1092  bool message;
1093} _InvalidObjectException__isset;
1094
1095class InvalidObjectException : public ::apache::thrift::TException {
1096 public:
1097
1098  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
1099  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
1100
1101  InvalidObjectException() : message("") {
1102  }
1103
1104  virtual ~InvalidObjectException() throw() {}
1105
1106  std::string message;
1107
1108  _InvalidObjectException__isset __isset;
1109
1110  bool operator == (const InvalidObjectException & rhs) const
1111  {
1112    if (!(message == rhs.message))
1113      return false;
1114    return true;
1115  }
1116  bool operator != (const InvalidObjectException &rhs) const {
1117    return !(*this == rhs);
1118  }
1119
1120  bool operator < (const InvalidObjectException & ) const;
1121
1122  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1123  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1124
1125};
1126
1127typedef struct _NoSuchObjectException__isset {
1128  _NoSuchObjectException__isset() : message(false) {}
1129  bool message;
1130} _NoSuchObjectException__isset;
1131
1132class NoSuchObjectException : public ::apache::thrift::TException {
1133 public:
1134
1135  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
1136  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
1137
1138  NoSuchObjectException() : message("") {
1139  }
1140
1141  virtual ~NoSuchObjectException() throw() {}
1142
1143  std::string message;
1144
1145  _NoSuchObjectException__isset __isset;
1146
1147  bool operator == (const NoSuchObjectException & rhs) const
1148  {
1149    if (!(message == rhs.message))
1150      return false;
1151    return true;
1152  }
1153  bool operator != (const NoSuchObjectException &rhs) const {
1154    return !(*this == rhs);
1155  }
1156
1157  bool operator < (const NoSuchObjectException & ) const;
1158
1159  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1160  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1161
1162};
1163
1164typedef struct _IndexAlreadyExistsException__isset {
1165  _IndexAlreadyExistsException__isset() : message(false) {}
1166  bool message;
1167} _IndexAlreadyExistsException__isset;
1168
1169class IndexAlreadyExistsException : public ::apache::thrift::TException {
1170 public:
1171
1172  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
1173  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
1174
1175  IndexAlreadyExistsException() : message("") {
1176  }
1177
1178  virtual ~IndexAlreadyExistsException() throw() {}
1179
1180  std::string message;
1181
1182  _IndexAlreadyExistsException__isset __isset;
1183
1184  bool operator == (const IndexAlreadyExistsException & rhs) const
1185  {
1186    if (!(message == rhs.message))
1187      return false;
1188    return true;
1189  }
1190  bool operator != (const IndexAlreadyExistsException &rhs) const {
1191    return !(*this == rhs);
1192  }
1193
1194  bool operator < (const IndexAlreadyExistsException & ) const;
1195
1196  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1197  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1198
1199};
1200
1201typedef struct _InvalidOperationException__isset {
1202  _InvalidOperationException__isset() : message(false) {}
1203  bool message;
1204} _InvalidOperationException__isset;
1205
1206class InvalidOperationException : public ::apache::thrift::TException {
1207 public:
1208
1209  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
1210  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
1211
1212  InvalidOperationException() : message("") {
1213  }
1214
1215  virtual ~InvalidOperationException() throw() {}
1216
1217  std::string message;
1218
1219  _InvalidOperationException__isset __isset;
1220
1221  bool operator == (const InvalidOperationException & rhs) const
1222  {
1223    if (!(message == rhs.message))
1224      return false;
1225    return true;
1226  }
1227  bool operator != (const InvalidOperationException &rhs) const {
1228    return !(*this == rhs);
1229  }
1230
1231  bool operator < (const InvalidOperationException & ) const;
1232
1233  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1234  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1235
1236};
1237
1238typedef struct _ConfigValSecurityException__isset {
1239  _ConfigValSecurityException__isset() : message(false) {}
1240  bool message;
1241} _ConfigValSecurityException__isset;
1242
1243class ConfigValSecurityException : public ::apache::thrift::TException {
1244 public:
1245
1246  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
1247  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
1248
1249  ConfigValSecurityException() : message("") {
1250  }
1251
1252  virtual ~ConfigValSecurityException() throw() {}
1253
1254  std::string message;
1255
1256  _ConfigValSecurityException__isset __isset;
1257
1258  bool operator == (const ConfigValSecurityException & rhs) const
1259  {
1260    if (!(message == rhs.message))
1261      return false;
1262    return true;
1263  }
1264  bool operator != (const ConfigValSecurityException &rhs) const {
1265    return !(*this == rhs);
1266  }
1267
1268  bool operator < (const ConfigValSecurityException & ) const;
1269
1270  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1271  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1272
1273};
1274
1275}}} // namespace
1276
1277#endif