/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