PageRenderTime 186ms CodeModel.GetById 20ms app.highlight 155ms RepoModel.GetById 1ms app.codeStats 1ms

/tags/release-0.0.0-rc0/hive/external/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp

#
C++ | 2638 lines | 2371 code | 262 blank | 5 comment | 452 complexity | 465547178399cd745c3192f4322e7405 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1/**
   2 * Autogenerated by Thrift
   3 *
   4 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
   5 */
   6#include "hive_metastore_types.h"
   7
   8namespace Apache { namespace Hadoop { namespace Hive {
   9
  10const char* Version::ascii_fingerprint = "07A9615F837F7D0A952B595DD3020972";
  11const uint8_t Version::binary_fingerprint[16] = {0x07,0xA9,0x61,0x5F,0x83,0x7F,0x7D,0x0A,0x95,0x2B,0x59,0x5D,0xD3,0x02,0x09,0x72};
  12
  13uint32_t Version::read(::apache::thrift::protocol::TProtocol* iprot) {
  14
  15  uint32_t xfer = 0;
  16  std::string fname;
  17  ::apache::thrift::protocol::TType ftype;
  18  int16_t fid;
  19
  20  xfer += iprot->readStructBegin(fname);
  21
  22  using ::apache::thrift::protocol::TProtocolException;
  23
  24
  25  while (true)
  26  {
  27    xfer += iprot->readFieldBegin(fname, ftype, fid);
  28    if (ftype == ::apache::thrift::protocol::T_STOP) {
  29      break;
  30    }
  31    switch (fid)
  32    {
  33      case 1:
  34        if (ftype == ::apache::thrift::protocol::T_STRING) {
  35          xfer += iprot->readString(this->version);
  36          this->__isset.version = true;
  37        } else {
  38          xfer += iprot->skip(ftype);
  39        }
  40        break;
  41      case 2:
  42        if (ftype == ::apache::thrift::protocol::T_STRING) {
  43          xfer += iprot->readString(this->comments);
  44          this->__isset.comments = true;
  45        } else {
  46          xfer += iprot->skip(ftype);
  47        }
  48        break;
  49      default:
  50        xfer += iprot->skip(ftype);
  51        break;
  52    }
  53    xfer += iprot->readFieldEnd();
  54  }
  55
  56  xfer += iprot->readStructEnd();
  57
  58  return xfer;
  59}
  60
  61uint32_t Version::write(::apache::thrift::protocol::TProtocol* oprot) const {
  62  uint32_t xfer = 0;
  63  xfer += oprot->writeStructBegin("Version");
  64  xfer += oprot->writeFieldBegin("version", ::apache::thrift::protocol::T_STRING, 1);
  65  xfer += oprot->writeString(this->version);
  66  xfer += oprot->writeFieldEnd();
  67  xfer += oprot->writeFieldBegin("comments", ::apache::thrift::protocol::T_STRING, 2);
  68  xfer += oprot->writeString(this->comments);
  69  xfer += oprot->writeFieldEnd();
  70  xfer += oprot->writeFieldStop();
  71  xfer += oprot->writeStructEnd();
  72  return xfer;
  73}
  74
  75const char* FieldSchema::ascii_fingerprint = "AB879940BD15B6B25691265F7384B271";
  76const uint8_t FieldSchema::binary_fingerprint[16] = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71};
  77
  78uint32_t FieldSchema::read(::apache::thrift::protocol::TProtocol* iprot) {
  79
  80  uint32_t xfer = 0;
  81  std::string fname;
  82  ::apache::thrift::protocol::TType ftype;
  83  int16_t fid;
  84
  85  xfer += iprot->readStructBegin(fname);
  86
  87  using ::apache::thrift::protocol::TProtocolException;
  88
  89
  90  while (true)
  91  {
  92    xfer += iprot->readFieldBegin(fname, ftype, fid);
  93    if (ftype == ::apache::thrift::protocol::T_STOP) {
  94      break;
  95    }
  96    switch (fid)
  97    {
  98      case 1:
  99        if (ftype == ::apache::thrift::protocol::T_STRING) {
 100          xfer += iprot->readString(this->name);
 101          this->__isset.name = true;
 102        } else {
 103          xfer += iprot->skip(ftype);
 104        }
 105        break;
 106      case 2:
 107        if (ftype == ::apache::thrift::protocol::T_STRING) {
 108          xfer += iprot->readString(this->type);
 109          this->__isset.type = true;
 110        } else {
 111          xfer += iprot->skip(ftype);
 112        }
 113        break;
 114      case 3:
 115        if (ftype == ::apache::thrift::protocol::T_STRING) {
 116          xfer += iprot->readString(this->comment);
 117          this->__isset.comment = true;
 118        } else {
 119          xfer += iprot->skip(ftype);
 120        }
 121        break;
 122      default:
 123        xfer += iprot->skip(ftype);
 124        break;
 125    }
 126    xfer += iprot->readFieldEnd();
 127  }
 128
 129  xfer += iprot->readStructEnd();
 130
 131  return xfer;
 132}
 133
 134uint32_t FieldSchema::write(::apache::thrift::protocol::TProtocol* oprot) const {
 135  uint32_t xfer = 0;
 136  xfer += oprot->writeStructBegin("FieldSchema");
 137  xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
 138  xfer += oprot->writeString(this->name);
 139  xfer += oprot->writeFieldEnd();
 140  xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_STRING, 2);
 141  xfer += oprot->writeString(this->type);
 142  xfer += oprot->writeFieldEnd();
 143  xfer += oprot->writeFieldBegin("comment", ::apache::thrift::protocol::T_STRING, 3);
 144  xfer += oprot->writeString(this->comment);
 145  xfer += oprot->writeFieldEnd();
 146  xfer += oprot->writeFieldStop();
 147  xfer += oprot->writeStructEnd();
 148  return xfer;
 149}
 150
 151const char* Type::ascii_fingerprint = "20DF02DE523C27F7066C7BD4D9120842";
 152const uint8_t Type::binary_fingerprint[16] = {0x20,0xDF,0x02,0xDE,0x52,0x3C,0x27,0xF7,0x06,0x6C,0x7B,0xD4,0xD9,0x12,0x08,0x42};
 153
 154uint32_t Type::read(::apache::thrift::protocol::TProtocol* iprot) {
 155
 156  uint32_t xfer = 0;
 157  std::string fname;
 158  ::apache::thrift::protocol::TType ftype;
 159  int16_t fid;
 160
 161  xfer += iprot->readStructBegin(fname);
 162
 163  using ::apache::thrift::protocol::TProtocolException;
 164
 165
 166  while (true)
 167  {
 168    xfer += iprot->readFieldBegin(fname, ftype, fid);
 169    if (ftype == ::apache::thrift::protocol::T_STOP) {
 170      break;
 171    }
 172    switch (fid)
 173    {
 174      case 1:
 175        if (ftype == ::apache::thrift::protocol::T_STRING) {
 176          xfer += iprot->readString(this->name);
 177          this->__isset.name = true;
 178        } else {
 179          xfer += iprot->skip(ftype);
 180        }
 181        break;
 182      case 2:
 183        if (ftype == ::apache::thrift::protocol::T_STRING) {
 184          xfer += iprot->readString(this->type1);
 185          this->__isset.type1 = true;
 186        } else {
 187          xfer += iprot->skip(ftype);
 188        }
 189        break;
 190      case 3:
 191        if (ftype == ::apache::thrift::protocol::T_STRING) {
 192          xfer += iprot->readString(this->type2);
 193          this->__isset.type2 = true;
 194        } else {
 195          xfer += iprot->skip(ftype);
 196        }
 197        break;
 198      case 4:
 199        if (ftype == ::apache::thrift::protocol::T_LIST) {
 200          {
 201            this->fields.clear();
 202            uint32_t _size0;
 203            ::apache::thrift::protocol::TType _etype3;
 204            iprot->readListBegin(_etype3, _size0);
 205            this->fields.resize(_size0);
 206            uint32_t _i4;
 207            for (_i4 = 0; _i4 < _size0; ++_i4)
 208            {
 209              xfer += this->fields[_i4].read(iprot);
 210            }
 211            iprot->readListEnd();
 212          }
 213          this->__isset.fields = true;
 214        } else {
 215          xfer += iprot->skip(ftype);
 216        }
 217        break;
 218      default:
 219        xfer += iprot->skip(ftype);
 220        break;
 221    }
 222    xfer += iprot->readFieldEnd();
 223  }
 224
 225  xfer += iprot->readStructEnd();
 226
 227  return xfer;
 228}
 229
 230uint32_t Type::write(::apache::thrift::protocol::TProtocol* oprot) const {
 231  uint32_t xfer = 0;
 232  xfer += oprot->writeStructBegin("Type");
 233  xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
 234  xfer += oprot->writeString(this->name);
 235  xfer += oprot->writeFieldEnd();
 236  if (this->__isset.type1) {
 237    xfer += oprot->writeFieldBegin("type1", ::apache::thrift::protocol::T_STRING, 2);
 238    xfer += oprot->writeString(this->type1);
 239    xfer += oprot->writeFieldEnd();
 240  }
 241  if (this->__isset.type2) {
 242    xfer += oprot->writeFieldBegin("type2", ::apache::thrift::protocol::T_STRING, 3);
 243    xfer += oprot->writeString(this->type2);
 244    xfer += oprot->writeFieldEnd();
 245  }
 246  if (this->__isset.fields) {
 247    xfer += oprot->writeFieldBegin("fields", ::apache::thrift::protocol::T_LIST, 4);
 248    {
 249      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, this->fields.size());
 250      std::vector<FieldSchema> ::const_iterator _iter5;
 251      for (_iter5 = this->fields.begin(); _iter5 != this->fields.end(); ++_iter5)
 252      {
 253        xfer += (*_iter5).write(oprot);
 254      }
 255      xfer += oprot->writeListEnd();
 256    }
 257    xfer += oprot->writeFieldEnd();
 258  }
 259  xfer += oprot->writeFieldStop();
 260  xfer += oprot->writeStructEnd();
 261  return xfer;
 262}
 263
 264const char* HiveObjectRef::ascii_fingerprint = "205CD8311CF3AA9EC161BAEF8D7C933C";
 265const uint8_t HiveObjectRef::binary_fingerprint[16] = {0x20,0x5C,0xD8,0x31,0x1C,0xF3,0xAA,0x9E,0xC1,0x61,0xBA,0xEF,0x8D,0x7C,0x93,0x3C};
 266
 267uint32_t HiveObjectRef::read(::apache::thrift::protocol::TProtocol* iprot) {
 268
 269  uint32_t xfer = 0;
 270  std::string fname;
 271  ::apache::thrift::protocol::TType ftype;
 272  int16_t fid;
 273
 274  xfer += iprot->readStructBegin(fname);
 275
 276  using ::apache::thrift::protocol::TProtocolException;
 277
 278
 279  while (true)
 280  {
 281    xfer += iprot->readFieldBegin(fname, ftype, fid);
 282    if (ftype == ::apache::thrift::protocol::T_STOP) {
 283      break;
 284    }
 285    switch (fid)
 286    {
 287      case 1:
 288        if (ftype == ::apache::thrift::protocol::T_I32) {
 289          int32_t ecast6;
 290          xfer += iprot->readI32(ecast6);
 291          this->objectType = (HiveObjectType::type)ecast6;
 292          this->__isset.objectType = true;
 293        } else {
 294          xfer += iprot->skip(ftype);
 295        }
 296        break;
 297      case 2:
 298        if (ftype == ::apache::thrift::protocol::T_STRING) {
 299          xfer += iprot->readString(this->dbName);
 300          this->__isset.dbName = true;
 301        } else {
 302          xfer += iprot->skip(ftype);
 303        }
 304        break;
 305      case 3:
 306        if (ftype == ::apache::thrift::protocol::T_STRING) {
 307          xfer += iprot->readString(this->objectName);
 308          this->__isset.objectName = true;
 309        } else {
 310          xfer += iprot->skip(ftype);
 311        }
 312        break;
 313      case 4:
 314        if (ftype == ::apache::thrift::protocol::T_LIST) {
 315          {
 316            this->partValues.clear();
 317            uint32_t _size7;
 318            ::apache::thrift::protocol::TType _etype10;
 319            iprot->readListBegin(_etype10, _size7);
 320            this->partValues.resize(_size7);
 321            uint32_t _i11;
 322            for (_i11 = 0; _i11 < _size7; ++_i11)
 323            {
 324              xfer += iprot->readString(this->partValues[_i11]);
 325            }
 326            iprot->readListEnd();
 327          }
 328          this->__isset.partValues = true;
 329        } else {
 330          xfer += iprot->skip(ftype);
 331        }
 332        break;
 333      case 5:
 334        if (ftype == ::apache::thrift::protocol::T_STRING) {
 335          xfer += iprot->readString(this->columnName);
 336          this->__isset.columnName = true;
 337        } else {
 338          xfer += iprot->skip(ftype);
 339        }
 340        break;
 341      default:
 342        xfer += iprot->skip(ftype);
 343        break;
 344    }
 345    xfer += iprot->readFieldEnd();
 346  }
 347
 348  xfer += iprot->readStructEnd();
 349
 350  return xfer;
 351}
 352
 353uint32_t HiveObjectRef::write(::apache::thrift::protocol::TProtocol* oprot) const {
 354  uint32_t xfer = 0;
 355  xfer += oprot->writeStructBegin("HiveObjectRef");
 356  xfer += oprot->writeFieldBegin("objectType", ::apache::thrift::protocol::T_I32, 1);
 357  xfer += oprot->writeI32((int32_t)this->objectType);
 358  xfer += oprot->writeFieldEnd();
 359  xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2);
 360  xfer += oprot->writeString(this->dbName);
 361  xfer += oprot->writeFieldEnd();
 362  xfer += oprot->writeFieldBegin("objectName", ::apache::thrift::protocol::T_STRING, 3);
 363  xfer += oprot->writeString(this->objectName);
 364  xfer += oprot->writeFieldEnd();
 365  xfer += oprot->writeFieldBegin("partValues", ::apache::thrift::protocol::T_LIST, 4);
 366  {
 367    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, this->partValues.size());
 368    std::vector<std::string> ::const_iterator _iter12;
 369    for (_iter12 = this->partValues.begin(); _iter12 != this->partValues.end(); ++_iter12)
 370    {
 371      xfer += oprot->writeString((*_iter12));
 372    }
 373    xfer += oprot->writeListEnd();
 374  }
 375  xfer += oprot->writeFieldEnd();
 376  xfer += oprot->writeFieldBegin("columnName", ::apache::thrift::protocol::T_STRING, 5);
 377  xfer += oprot->writeString(this->columnName);
 378  xfer += oprot->writeFieldEnd();
 379  xfer += oprot->writeFieldStop();
 380  xfer += oprot->writeStructEnd();
 381  return xfer;
 382}
 383
 384const char* PrivilegeGrantInfo::ascii_fingerprint = "A58923AF7294BE492D6F90E07E8CEE1F";
 385const uint8_t PrivilegeGrantInfo::binary_fingerprint[16] = {0xA5,0x89,0x23,0xAF,0x72,0x94,0xBE,0x49,0x2D,0x6F,0x90,0xE0,0x7E,0x8C,0xEE,0x1F};
 386
 387uint32_t PrivilegeGrantInfo::read(::apache::thrift::protocol::TProtocol* iprot) {
 388
 389  uint32_t xfer = 0;
 390  std::string fname;
 391  ::apache::thrift::protocol::TType ftype;
 392  int16_t fid;
 393
 394  xfer += iprot->readStructBegin(fname);
 395
 396  using ::apache::thrift::protocol::TProtocolException;
 397
 398
 399  while (true)
 400  {
 401    xfer += iprot->readFieldBegin(fname, ftype, fid);
 402    if (ftype == ::apache::thrift::protocol::T_STOP) {
 403      break;
 404    }
 405    switch (fid)
 406    {
 407      case 1:
 408        if (ftype == ::apache::thrift::protocol::T_STRING) {
 409          xfer += iprot->readString(this->privilege);
 410          this->__isset.privilege = true;
 411        } else {
 412          xfer += iprot->skip(ftype);
 413        }
 414        break;
 415      case 2:
 416        if (ftype == ::apache::thrift::protocol::T_I32) {
 417          xfer += iprot->readI32(this->createTime);
 418          this->__isset.createTime = true;
 419        } else {
 420          xfer += iprot->skip(ftype);
 421        }
 422        break;
 423      case 3:
 424        if (ftype == ::apache::thrift::protocol::T_STRING) {
 425          xfer += iprot->readString(this->grantor);
 426          this->__isset.grantor = true;
 427        } else {
 428          xfer += iprot->skip(ftype);
 429        }
 430        break;
 431      case 4:
 432        if (ftype == ::apache::thrift::protocol::T_I32) {
 433          int32_t ecast13;
 434          xfer += iprot->readI32(ecast13);
 435          this->grantorType = (PrincipalType::type)ecast13;
 436          this->__isset.grantorType = true;
 437        } else {
 438          xfer += iprot->skip(ftype);
 439        }
 440        break;
 441      case 5:
 442        if (ftype == ::apache::thrift::protocol::T_BOOL) {
 443          xfer += iprot->readBool(this->grantOption);
 444          this->__isset.grantOption = true;
 445        } else {
 446          xfer += iprot->skip(ftype);
 447        }
 448        break;
 449      default:
 450        xfer += iprot->skip(ftype);
 451        break;
 452    }
 453    xfer += iprot->readFieldEnd();
 454  }
 455
 456  xfer += iprot->readStructEnd();
 457
 458  return xfer;
 459}
 460
 461uint32_t PrivilegeGrantInfo::write(::apache::thrift::protocol::TProtocol* oprot) const {
 462  uint32_t xfer = 0;
 463  xfer += oprot->writeStructBegin("PrivilegeGrantInfo");
 464  xfer += oprot->writeFieldBegin("privilege", ::apache::thrift::protocol::T_STRING, 1);
 465  xfer += oprot->writeString(this->privilege);
 466  xfer += oprot->writeFieldEnd();
 467  xfer += oprot->writeFieldBegin("createTime", ::apache::thrift::protocol::T_I32, 2);
 468  xfer += oprot->writeI32(this->createTime);
 469  xfer += oprot->writeFieldEnd();
 470  xfer += oprot->writeFieldBegin("grantor", ::apache::thrift::protocol::T_STRING, 3);
 471  xfer += oprot->writeString(this->grantor);
 472  xfer += oprot->writeFieldEnd();
 473  xfer += oprot->writeFieldBegin("grantorType", ::apache::thrift::protocol::T_I32, 4);
 474  xfer += oprot->writeI32((int32_t)this->grantorType);
 475  xfer += oprot->writeFieldEnd();
 476  xfer += oprot->writeFieldBegin("grantOption", ::apache::thrift::protocol::T_BOOL, 5);
 477  xfer += oprot->writeBool(this->grantOption);
 478  xfer += oprot->writeFieldEnd();
 479  xfer += oprot->writeFieldStop();
 480  xfer += oprot->writeStructEnd();
 481  return xfer;
 482}
 483
 484const char* HiveObjectPrivilege::ascii_fingerprint = "83D71969B23BD853E29DBA9D43B29AF8";
 485const uint8_t HiveObjectPrivilege::binary_fingerprint[16] = {0x83,0xD7,0x19,0x69,0xB2,0x3B,0xD8,0x53,0xE2,0x9D,0xBA,0x9D,0x43,0xB2,0x9A,0xF8};
 486
 487uint32_t HiveObjectPrivilege::read(::apache::thrift::protocol::TProtocol* iprot) {
 488
 489  uint32_t xfer = 0;
 490  std::string fname;
 491  ::apache::thrift::protocol::TType ftype;
 492  int16_t fid;
 493
 494  xfer += iprot->readStructBegin(fname);
 495
 496  using ::apache::thrift::protocol::TProtocolException;
 497
 498
 499  while (true)
 500  {
 501    xfer += iprot->readFieldBegin(fname, ftype, fid);
 502    if (ftype == ::apache::thrift::protocol::T_STOP) {
 503      break;
 504    }
 505    switch (fid)
 506    {
 507      case 1:
 508        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
 509          xfer += this->hiveObject.read(iprot);
 510          this->__isset.hiveObject = true;
 511        } else {
 512          xfer += iprot->skip(ftype);
 513        }
 514        break;
 515      case 2:
 516        if (ftype == ::apache::thrift::protocol::T_STRING) {
 517          xfer += iprot->readString(this->principalName);
 518          this->__isset.principalName = true;
 519        } else {
 520          xfer += iprot->skip(ftype);
 521        }
 522        break;
 523      case 3:
 524        if (ftype == ::apache::thrift::protocol::T_I32) {
 525          int32_t ecast14;
 526          xfer += iprot->readI32(ecast14);
 527          this->principalType = (PrincipalType::type)ecast14;
 528          this->__isset.principalType = true;
 529        } else {
 530          xfer += iprot->skip(ftype);
 531        }
 532        break;
 533      case 4:
 534        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
 535          xfer += this->grantInfo.read(iprot);
 536          this->__isset.grantInfo = true;
 537        } else {
 538          xfer += iprot->skip(ftype);
 539        }
 540        break;
 541      default:
 542        xfer += iprot->skip(ftype);
 543        break;
 544    }
 545    xfer += iprot->readFieldEnd();
 546  }
 547
 548  xfer += iprot->readStructEnd();
 549
 550  return xfer;
 551}
 552
 553uint32_t HiveObjectPrivilege::write(::apache::thrift::protocol::TProtocol* oprot) const {
 554  uint32_t xfer = 0;
 555  xfer += oprot->writeStructBegin("HiveObjectPrivilege");
 556  xfer += oprot->writeFieldBegin("hiveObject", ::apache::thrift::protocol::T_STRUCT, 1);
 557  xfer += this->hiveObject.write(oprot);
 558  xfer += oprot->writeFieldEnd();
 559  xfer += oprot->writeFieldBegin("principalName", ::apache::thrift::protocol::T_STRING, 2);
 560  xfer += oprot->writeString(this->principalName);
 561  xfer += oprot->writeFieldEnd();
 562  xfer += oprot->writeFieldBegin("principalType", ::apache::thrift::protocol::T_I32, 3);
 563  xfer += oprot->writeI32((int32_t)this->principalType);
 564  xfer += oprot->writeFieldEnd();
 565  xfer += oprot->writeFieldBegin("grantInfo", ::apache::thrift::protocol::T_STRUCT, 4);
 566  xfer += this->grantInfo.write(oprot);
 567  xfer += oprot->writeFieldEnd();
 568  xfer += oprot->writeFieldStop();
 569  xfer += oprot->writeStructEnd();
 570  return xfer;
 571}
 572
 573const char* PrivilegeBag::ascii_fingerprint = "BB89E4701B7B709B046A74C90B1147F2";
 574const uint8_t PrivilegeBag::binary_fingerprint[16] = {0xBB,0x89,0xE4,0x70,0x1B,0x7B,0x70,0x9B,0x04,0x6A,0x74,0xC9,0x0B,0x11,0x47,0xF2};
 575
 576uint32_t PrivilegeBag::read(::apache::thrift::protocol::TProtocol* iprot) {
 577
 578  uint32_t xfer = 0;
 579  std::string fname;
 580  ::apache::thrift::protocol::TType ftype;
 581  int16_t fid;
 582
 583  xfer += iprot->readStructBegin(fname);
 584
 585  using ::apache::thrift::protocol::TProtocolException;
 586
 587
 588  while (true)
 589  {
 590    xfer += iprot->readFieldBegin(fname, ftype, fid);
 591    if (ftype == ::apache::thrift::protocol::T_STOP) {
 592      break;
 593    }
 594    switch (fid)
 595    {
 596      case 1:
 597        if (ftype == ::apache::thrift::protocol::T_LIST) {
 598          {
 599            this->privileges.clear();
 600            uint32_t _size15;
 601            ::apache::thrift::protocol::TType _etype18;
 602            iprot->readListBegin(_etype18, _size15);
 603            this->privileges.resize(_size15);
 604            uint32_t _i19;
 605            for (_i19 = 0; _i19 < _size15; ++_i19)
 606            {
 607              xfer += this->privileges[_i19].read(iprot);
 608            }
 609            iprot->readListEnd();
 610          }
 611          this->__isset.privileges = true;
 612        } else {
 613          xfer += iprot->skip(ftype);
 614        }
 615        break;
 616      default:
 617        xfer += iprot->skip(ftype);
 618        break;
 619    }
 620    xfer += iprot->readFieldEnd();
 621  }
 622
 623  xfer += iprot->readStructEnd();
 624
 625  return xfer;
 626}
 627
 628uint32_t PrivilegeBag::write(::apache::thrift::protocol::TProtocol* oprot) const {
 629  uint32_t xfer = 0;
 630  xfer += oprot->writeStructBegin("PrivilegeBag");
 631  xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_LIST, 1);
 632  {
 633    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, this->privileges.size());
 634    std::vector<HiveObjectPrivilege> ::const_iterator _iter20;
 635    for (_iter20 = this->privileges.begin(); _iter20 != this->privileges.end(); ++_iter20)
 636    {
 637      xfer += (*_iter20).write(oprot);
 638    }
 639    xfer += oprot->writeListEnd();
 640  }
 641  xfer += oprot->writeFieldEnd();
 642  xfer += oprot->writeFieldStop();
 643  xfer += oprot->writeStructEnd();
 644  return xfer;
 645}
 646
 647const char* PrincipalPrivilegeSet::ascii_fingerprint = "08F75D2533906EA87BE34EA640856683";
 648const uint8_t PrincipalPrivilegeSet::binary_fingerprint[16] = {0x08,0xF7,0x5D,0x25,0x33,0x90,0x6E,0xA8,0x7B,0xE3,0x4E,0xA6,0x40,0x85,0x66,0x83};
 649
 650uint32_t PrincipalPrivilegeSet::read(::apache::thrift::protocol::TProtocol* iprot) {
 651
 652  uint32_t xfer = 0;
 653  std::string fname;
 654  ::apache::thrift::protocol::TType ftype;
 655  int16_t fid;
 656
 657  xfer += iprot->readStructBegin(fname);
 658
 659  using ::apache::thrift::protocol::TProtocolException;
 660
 661
 662  while (true)
 663  {
 664    xfer += iprot->readFieldBegin(fname, ftype, fid);
 665    if (ftype == ::apache::thrift::protocol::T_STOP) {
 666      break;
 667    }
 668    switch (fid)
 669    {
 670      case 1:
 671        if (ftype == ::apache::thrift::protocol::T_MAP) {
 672          {
 673            this->userPrivileges.clear();
 674            uint32_t _size21;
 675            ::apache::thrift::protocol::TType _ktype22;
 676            ::apache::thrift::protocol::TType _vtype23;
 677            iprot->readMapBegin(_ktype22, _vtype23, _size21);
 678            uint32_t _i25;
 679            for (_i25 = 0; _i25 < _size21; ++_i25)
 680            {
 681              std::string _key26;
 682              xfer += iprot->readString(_key26);
 683              std::vector<PrivilegeGrantInfo> & _val27 = this->userPrivileges[_key26];
 684              {
 685                _val27.clear();
 686                uint32_t _size28;
 687                ::apache::thrift::protocol::TType _etype31;
 688                iprot->readListBegin(_etype31, _size28);
 689                _val27.resize(_size28);
 690                uint32_t _i32;
 691                for (_i32 = 0; _i32 < _size28; ++_i32)
 692                {
 693                  xfer += _val27[_i32].read(iprot);
 694                }
 695                iprot->readListEnd();
 696              }
 697            }
 698            iprot->readMapEnd();
 699          }
 700          this->__isset.userPrivileges = true;
 701        } else {
 702          xfer += iprot->skip(ftype);
 703        }
 704        break;
 705      case 2:
 706        if (ftype == ::apache::thrift::protocol::T_MAP) {
 707          {
 708            this->groupPrivileges.clear();
 709            uint32_t _size33;
 710            ::apache::thrift::protocol::TType _ktype34;
 711            ::apache::thrift::protocol::TType _vtype35;
 712            iprot->readMapBegin(_ktype34, _vtype35, _size33);
 713            uint32_t _i37;
 714            for (_i37 = 0; _i37 < _size33; ++_i37)
 715            {
 716              std::string _key38;
 717              xfer += iprot->readString(_key38);
 718              std::vector<PrivilegeGrantInfo> & _val39 = this->groupPrivileges[_key38];
 719              {
 720                _val39.clear();
 721                uint32_t _size40;
 722                ::apache::thrift::protocol::TType _etype43;
 723                iprot->readListBegin(_etype43, _size40);
 724                _val39.resize(_size40);
 725                uint32_t _i44;
 726                for (_i44 = 0; _i44 < _size40; ++_i44)
 727                {
 728                  xfer += _val39[_i44].read(iprot);
 729                }
 730                iprot->readListEnd();
 731              }
 732            }
 733            iprot->readMapEnd();
 734          }
 735          this->__isset.groupPrivileges = true;
 736        } else {
 737          xfer += iprot->skip(ftype);
 738        }
 739        break;
 740      case 3:
 741        if (ftype == ::apache::thrift::protocol::T_MAP) {
 742          {
 743            this->rolePrivileges.clear();
 744            uint32_t _size45;
 745            ::apache::thrift::protocol::TType _ktype46;
 746            ::apache::thrift::protocol::TType _vtype47;
 747            iprot->readMapBegin(_ktype46, _vtype47, _size45);
 748            uint32_t _i49;
 749            for (_i49 = 0; _i49 < _size45; ++_i49)
 750            {
 751              std::string _key50;
 752              xfer += iprot->readString(_key50);
 753              std::vector<PrivilegeGrantInfo> & _val51 = this->rolePrivileges[_key50];
 754              {
 755                _val51.clear();
 756                uint32_t _size52;
 757                ::apache::thrift::protocol::TType _etype55;
 758                iprot->readListBegin(_etype55, _size52);
 759                _val51.resize(_size52);
 760                uint32_t _i56;
 761                for (_i56 = 0; _i56 < _size52; ++_i56)
 762                {
 763                  xfer += _val51[_i56].read(iprot);
 764                }
 765                iprot->readListEnd();
 766              }
 767            }
 768            iprot->readMapEnd();
 769          }
 770          this->__isset.rolePrivileges = true;
 771        } else {
 772          xfer += iprot->skip(ftype);
 773        }
 774        break;
 775      default:
 776        xfer += iprot->skip(ftype);
 777        break;
 778    }
 779    xfer += iprot->readFieldEnd();
 780  }
 781
 782  xfer += iprot->readStructEnd();
 783
 784  return xfer;
 785}
 786
 787uint32_t PrincipalPrivilegeSet::write(::apache::thrift::protocol::TProtocol* oprot) const {
 788  uint32_t xfer = 0;
 789  xfer += oprot->writeStructBegin("PrincipalPrivilegeSet");
 790  xfer += oprot->writeFieldBegin("userPrivileges", ::apache::thrift::protocol::T_MAP, 1);
 791  {
 792    xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, this->userPrivileges.size());
 793    std::map<std::string, std::vector<PrivilegeGrantInfo> > ::const_iterator _iter57;
 794    for (_iter57 = this->userPrivileges.begin(); _iter57 != this->userPrivileges.end(); ++_iter57)
 795    {
 796      xfer += oprot->writeString(_iter57->first);
 797      {
 798        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, _iter57->second.size());
 799        std::vector<PrivilegeGrantInfo> ::const_iterator _iter58;
 800        for (_iter58 = _iter57->second.begin(); _iter58 != _iter57->second.end(); ++_iter58)
 801        {
 802          xfer += (*_iter58).write(oprot);
 803        }
 804        xfer += oprot->writeListEnd();
 805      }
 806    }
 807    xfer += oprot->writeMapEnd();
 808  }
 809  xfer += oprot->writeFieldEnd();
 810  xfer += oprot->writeFieldBegin("groupPrivileges", ::apache::thrift::protocol::T_MAP, 2);
 811  {
 812    xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, this->groupPrivileges.size());
 813    std::map<std::string, std::vector<PrivilegeGrantInfo> > ::const_iterator _iter59;
 814    for (_iter59 = this->groupPrivileges.begin(); _iter59 != this->groupPrivileges.end(); ++_iter59)
 815    {
 816      xfer += oprot->writeString(_iter59->first);
 817      {
 818        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, _iter59->second.size());
 819        std::vector<PrivilegeGrantInfo> ::const_iterator _iter60;
 820        for (_iter60 = _iter59->second.begin(); _iter60 != _iter59->second.end(); ++_iter60)
 821        {
 822          xfer += (*_iter60).write(oprot);
 823        }
 824        xfer += oprot->writeListEnd();
 825      }
 826    }
 827    xfer += oprot->writeMapEnd();
 828  }
 829  xfer += oprot->writeFieldEnd();
 830  xfer += oprot->writeFieldBegin("rolePrivileges", ::apache::thrift::protocol::T_MAP, 3);
 831  {
 832    xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, this->rolePrivileges.size());
 833    std::map<std::string, std::vector<PrivilegeGrantInfo> > ::const_iterator _iter61;
 834    for (_iter61 = this->rolePrivileges.begin(); _iter61 != this->rolePrivileges.end(); ++_iter61)
 835    {
 836      xfer += oprot->writeString(_iter61->first);
 837      {
 838        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, _iter61->second.size());
 839        std::vector<PrivilegeGrantInfo> ::const_iterator _iter62;
 840        for (_iter62 = _iter61->second.begin(); _iter62 != _iter61->second.end(); ++_iter62)
 841        {
 842          xfer += (*_iter62).write(oprot);
 843        }
 844        xfer += oprot->writeListEnd();
 845      }
 846    }
 847    xfer += oprot->writeMapEnd();
 848  }
 849  xfer += oprot->writeFieldEnd();
 850  xfer += oprot->writeFieldStop();
 851  xfer += oprot->writeStructEnd();
 852  return xfer;
 853}
 854
 855const char* Role::ascii_fingerprint = "70563A0628F75DF9555F4D24690B1E26";
 856const uint8_t Role::binary_fingerprint[16] = {0x70,0x56,0x3A,0x06,0x28,0xF7,0x5D,0xF9,0x55,0x5F,0x4D,0x24,0x69,0x0B,0x1E,0x26};
 857
 858uint32_t Role::read(::apache::thrift::protocol::TProtocol* iprot) {
 859
 860  uint32_t xfer = 0;
 861  std::string fname;
 862  ::apache::thrift::protocol::TType ftype;
 863  int16_t fid;
 864
 865  xfer += iprot->readStructBegin(fname);
 866
 867  using ::apache::thrift::protocol::TProtocolException;
 868
 869
 870  while (true)
 871  {
 872    xfer += iprot->readFieldBegin(fname, ftype, fid);
 873    if (ftype == ::apache::thrift::protocol::T_STOP) {
 874      break;
 875    }
 876    switch (fid)
 877    {
 878      case 1:
 879        if (ftype == ::apache::thrift::protocol::T_STRING) {
 880          xfer += iprot->readString(this->roleName);
 881          this->__isset.roleName = true;
 882        } else {
 883          xfer += iprot->skip(ftype);
 884        }
 885        break;
 886      case 2:
 887        if (ftype == ::apache::thrift::protocol::T_I32) {
 888          xfer += iprot->readI32(this->createTime);
 889          this->__isset.createTime = true;
 890        } else {
 891          xfer += iprot->skip(ftype);
 892        }
 893        break;
 894      case 3:
 895        if (ftype == ::apache::thrift::protocol::T_STRING) {
 896          xfer += iprot->readString(this->ownerName);
 897          this->__isset.ownerName = true;
 898        } else {
 899          xfer += iprot->skip(ftype);
 900        }
 901        break;
 902      default:
 903        xfer += iprot->skip(ftype);
 904        break;
 905    }
 906    xfer += iprot->readFieldEnd();
 907  }
 908
 909  xfer += iprot->readStructEnd();
 910
 911  return xfer;
 912}
 913
 914uint32_t Role::write(::apache::thrift::protocol::TProtocol* oprot) const {
 915  uint32_t xfer = 0;
 916  xfer += oprot->writeStructBegin("Role");
 917  xfer += oprot->writeFieldBegin("roleName", ::apache::thrift::protocol::T_STRING, 1);
 918  xfer += oprot->writeString(this->roleName);
 919  xfer += oprot->writeFieldEnd();
 920  xfer += oprot->writeFieldBegin("createTime", ::apache::thrift::protocol::T_I32, 2);
 921  xfer += oprot->writeI32(this->createTime);
 922  xfer += oprot->writeFieldEnd();
 923  xfer += oprot->writeFieldBegin("ownerName", ::apache::thrift::protocol::T_STRING, 3);
 924  xfer += oprot->writeString(this->ownerName);
 925  xfer += oprot->writeFieldEnd();
 926  xfer += oprot->writeFieldStop();
 927  xfer += oprot->writeStructEnd();
 928  return xfer;
 929}
 930
 931const char* Database::ascii_fingerprint = "213967572143E49C9F1A23F7A866E2F5";
 932const uint8_t Database::binary_fingerprint[16] = {0x21,0x39,0x67,0x57,0x21,0x43,0xE4,0x9C,0x9F,0x1A,0x23,0xF7,0xA8,0x66,0xE2,0xF5};
 933
 934uint32_t Database::read(::apache::thrift::protocol::TProtocol* iprot) {
 935
 936  uint32_t xfer = 0;
 937  std::string fname;
 938  ::apache::thrift::protocol::TType ftype;
 939  int16_t fid;
 940
 941  xfer += iprot->readStructBegin(fname);
 942
 943  using ::apache::thrift::protocol::TProtocolException;
 944
 945
 946  while (true)
 947  {
 948    xfer += iprot->readFieldBegin(fname, ftype, fid);
 949    if (ftype == ::apache::thrift::protocol::T_STOP) {
 950      break;
 951    }
 952    switch (fid)
 953    {
 954      case 1:
 955        if (ftype == ::apache::thrift::protocol::T_STRING) {
 956          xfer += iprot->readString(this->name);
 957          this->__isset.name = true;
 958        } else {
 959          xfer += iprot->skip(ftype);
 960        }
 961        break;
 962      case 2:
 963        if (ftype == ::apache::thrift::protocol::T_STRING) {
 964          xfer += iprot->readString(this->description);
 965          this->__isset.description = true;
 966        } else {
 967          xfer += iprot->skip(ftype);
 968        }
 969        break;
 970      case 3:
 971        if (ftype == ::apache::thrift::protocol::T_STRING) {
 972          xfer += iprot->readString(this->locationUri);
 973          this->__isset.locationUri = true;
 974        } else {
 975          xfer += iprot->skip(ftype);
 976        }
 977        break;
 978      case 4:
 979        if (ftype == ::apache::thrift::protocol::T_MAP) {
 980          {
 981            this->parameters.clear();
 982            uint32_t _size63;
 983            ::apache::thrift::protocol::TType _ktype64;
 984            ::apache::thrift::protocol::TType _vtype65;
 985            iprot->readMapBegin(_ktype64, _vtype65, _size63);
 986            uint32_t _i67;
 987            for (_i67 = 0; _i67 < _size63; ++_i67)
 988            {
 989              std::string _key68;
 990              xfer += iprot->readString(_key68);
 991              std::string& _val69 = this->parameters[_key68];
 992              xfer += iprot->readString(_val69);
 993            }
 994            iprot->readMapEnd();
 995          }
 996          this->__isset.parameters = true;
 997        } else {
 998          xfer += iprot->skip(ftype);
 999        }
1000        break;
1001      case 5:
1002        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
1003          xfer += this->privileges.read(iprot);
1004          this->__isset.privileges = true;
1005        } else {
1006          xfer += iprot->skip(ftype);
1007        }
1008        break;
1009      default:
1010        xfer += iprot->skip(ftype);
1011        break;
1012    }
1013    xfer += iprot->readFieldEnd();
1014  }
1015
1016  xfer += iprot->readStructEnd();
1017
1018  return xfer;
1019}
1020
1021uint32_t Database::write(::apache::thrift::protocol::TProtocol* oprot) const {
1022  uint32_t xfer = 0;
1023  xfer += oprot->writeStructBegin("Database");
1024  xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
1025  xfer += oprot->writeString(this->name);
1026  xfer += oprot->writeFieldEnd();
1027  xfer += oprot->writeFieldBegin("description", ::apache::thrift::protocol::T_STRING, 2);
1028  xfer += oprot->writeString(this->description);
1029  xfer += oprot->writeFieldEnd();
1030  xfer += oprot->writeFieldBegin("locationUri", ::apache::thrift::protocol::T_STRING, 3);
1031  xfer += oprot->writeString(this->locationUri);
1032  xfer += oprot->writeFieldEnd();
1033  xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 4);
1034  {
1035    xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, this->parameters.size());
1036    std::map<std::string, std::string> ::const_iterator _iter70;
1037    for (_iter70 = this->parameters.begin(); _iter70 != this->parameters.end(); ++_iter70)
1038    {
1039      xfer += oprot->writeString(_iter70->first);
1040      xfer += oprot->writeString(_iter70->second);
1041    }
1042    xfer += oprot->writeMapEnd();
1043  }
1044  xfer += oprot->writeFieldEnd();
1045  if (this->__isset.privileges) {
1046    xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_STRUCT, 5);
1047    xfer += this->privileges.write(oprot);
1048    xfer += oprot->writeFieldEnd();
1049  }
1050  xfer += oprot->writeFieldStop();
1051  xfer += oprot->writeStructEnd();
1052  return xfer;
1053}
1054
1055const char* SerDeInfo::ascii_fingerprint = "B1021C32A35A2AEFCD2F57A5424159A7";
1056const uint8_t SerDeInfo::binary_fingerprint[16] = {0xB1,0x02,0x1C,0x32,0xA3,0x5A,0x2A,0xEF,0xCD,0x2F,0x57,0xA5,0x42,0x41,0x59,0xA7};
1057
1058uint32_t SerDeInfo::read(::apache::thrift::protocol::TProtocol* iprot) {
1059
1060  uint32_t xfer = 0;
1061  std::string fname;
1062  ::apache::thrift::protocol::TType ftype;
1063  int16_t fid;
1064
1065  xfer += iprot->readStructBegin(fname);
1066
1067  using ::apache::thrift::protocol::TProtocolException;
1068
1069
1070  while (true)
1071  {
1072    xfer += iprot->readFieldBegin(fname, ftype, fid);
1073    if (ftype == ::apache::thrift::protocol::T_STOP) {
1074      break;
1075    }
1076    switch (fid)
1077    {
1078      case 1:
1079        if (ftype == ::apache::thrift::protocol::T_STRING) {
1080          xfer += iprot->readString(this->name);
1081          this->__isset.name = true;
1082        } else {
1083          xfer += iprot->skip(ftype);
1084        }
1085        break;
1086      case 2:
1087        if (ftype == ::apache::thrift::protocol::T_STRING) {
1088          xfer += iprot->readString(this->serializationLib);
1089          this->__isset.serializationLib = true;
1090        } else {
1091          xfer += iprot->skip(ftype);
1092        }
1093        break;
1094      case 3:
1095        if (ftype == ::apache::thrift::protocol::T_MAP) {
1096          {
1097            this->parameters.clear();
1098            uint32_t _size71;
1099            ::apache::thrift::protocol::TType _ktype72;
1100            ::apache::thrift::protocol::TType _vtype73;
1101            iprot->readMapBegin(_ktype72, _vtype73, _size71);
1102            uint32_t _i75;
1103            for (_i75 = 0; _i75 < _size71; ++_i75)
1104            {
1105              std::string _key76;
1106              xfer += iprot->readString(_key76);
1107              std::string& _val77 = this->parameters[_key76];
1108              xfer += iprot->readString(_val77);
1109            }
1110            iprot->readMapEnd();
1111          }
1112          this->__isset.parameters = true;
1113        } else {
1114          xfer += iprot->skip(ftype);
1115        }
1116        break;
1117      default:
1118        xfer += iprot->skip(ftype);
1119        break;
1120    }
1121    xfer += iprot->readFieldEnd();
1122  }
1123
1124  xfer += iprot->readStructEnd();
1125
1126  return xfer;
1127}
1128
1129uint32_t SerDeInfo::write(::apache::thrift::protocol::TProtocol* oprot) const {
1130  uint32_t xfer = 0;
1131  xfer += oprot->writeStructBegin("SerDeInfo");
1132  xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
1133  xfer += oprot->writeString(this->name);
1134  xfer += oprot->writeFieldEnd();
1135  xfer += oprot->writeFieldBegin("serializationLib", ::apache::thrift::protocol::T_STRING, 2);
1136  xfer += oprot->writeString(this->serializationLib);
1137  xfer += oprot->writeFieldEnd();
1138  xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 3);
1139  {
1140    xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, this->parameters.size());
1141    std::map<std::string, std::string> ::const_iterator _iter78;
1142    for (_iter78 = this->parameters.begin(); _iter78 != this->parameters.end(); ++_iter78)
1143    {
1144      xfer += oprot->writeString(_iter78->first);
1145      xfer += oprot->writeString(_iter78->second);
1146    }
1147    xfer += oprot->writeMapEnd();
1148  }
1149  xfer += oprot->writeFieldEnd();
1150  xfer += oprot->writeFieldStop();
1151  xfer += oprot->writeStructEnd();
1152  return xfer;
1153}
1154
1155const char* Order::ascii_fingerprint = "EEBC915CE44901401D881E6091423036";
1156const uint8_t Order::binary_fingerprint[16] = {0xEE,0xBC,0x91,0x5C,0xE4,0x49,0x01,0x40,0x1D,0x88,0x1E,0x60,0x91,0x42,0x30,0x36};
1157
1158uint32_t Order::read(::apache::thrift::protocol::TProtocol* iprot) {
1159
1160  uint32_t xfer = 0;
1161  std::string fname;
1162  ::apache::thrift::protocol::TType ftype;
1163  int16_t fid;
1164
1165  xfer += iprot->readStructBegin(fname);
1166
1167  using ::apache::thrift::protocol::TProtocolException;
1168
1169
1170  while (true)
1171  {
1172    xfer += iprot->readFieldBegin(fname, ftype, fid);
1173    if (ftype == ::apache::thrift::protocol::T_STOP) {
1174      break;
1175    }
1176    switch (fid)
1177    {
1178      case 1:
1179        if (ftype == ::apache::thrift::protocol::T_STRING) {
1180          xfer += iprot->readString(this->col);
1181          this->__isset.col = true;
1182        } else {
1183          xfer += iprot->skip(ftype);
1184        }
1185        break;
1186      case 2:
1187        if (ftype == ::apache::thrift::protocol::T_I32) {
1188          xfer += iprot->readI32(this->order);
1189          this->__isset.order = true;
1190        } else {
1191          xfer += iprot->skip(ftype);
1192        }
1193        break;
1194      default:
1195        xfer += iprot->skip(ftype);
1196        break;
1197    }
1198    xfer += iprot->readFieldEnd();
1199  }
1200
1201  xfer += iprot->readStructEnd();
1202
1203  return xfer;
1204}
1205
1206uint32_t Order::write(::apache::thrift::protocol::TProtocol* oprot) const {
1207  uint32_t xfer = 0;
1208  xfer += oprot->writeStructBegin("Order");
1209  xfer += oprot->writeFieldBegin("col", ::apache::thrift::protocol::T_STRING, 1);
1210  xfer += oprot->writeString(this->col);
1211  xfer += oprot->writeFieldEnd();
1212  xfer += oprot->writeFieldBegin("order", ::apache::thrift::protocol::T_I32, 2);
1213  xfer += oprot->writeI32(this->order);
1214  xfer += oprot->writeFieldEnd();
1215  xfer += oprot->writeFieldStop();
1216  xfer += oprot->writeStructEnd();
1217  return xfer;
1218}
1219
1220const char* StorageDescriptor::ascii_fingerprint = "11E4CE18F895C13812C853DFDCD1293F";
1221const uint8_t StorageDescriptor::binary_fingerprint[16] = {0x11,0xE4,0xCE,0x18,0xF8,0x95,0xC1,0x38,0x12,0xC8,0x53,0xDF,0xDC,0xD1,0x29,0x3F};
1222
1223uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) {
1224
1225  uint32_t xfer = 0;
1226  std::string fname;
1227  ::apache::thrift::protocol::TType ftype;
1228  int16_t fid;
1229
1230  xfer += iprot->readStructBegin(fname);
1231
1232  using ::apache::thrift::protocol::TProtocolException;
1233
1234
1235  while (true)
1236  {
1237    xfer += iprot->readFieldBegin(fname, ftype, fid);
1238    if (ftype == ::apache::thrift::protocol::T_STOP) {
1239      break;
1240    }
1241    switch (fid)
1242    {
1243      case 1:
1244        if (ftype == ::apache::thrift::protocol::T_LIST) {
1245          {
1246            this->cols.clear();
1247            uint32_t _size79;
1248            ::apache::thrift::protocol::TType _etype82;
1249            iprot->readListBegin(_etype82, _size79);
1250            this->cols.resize(_size79);
1251            uint32_t _i83;
1252            for (_i83 = 0; _i83 < _size79; ++_i83)
1253            {
1254              xfer += this->cols[_i83].read(iprot);
1255            }
1256            iprot->readListEnd();
1257          }
1258          this->__isset.cols = true;
1259        } else {
1260          xfer += iprot->skip(ftype);
1261        }
1262        break;
1263      case 2:
1264        if (ftype == ::apache::thrift::protocol::T_STRING) {
1265          xfer += iprot->readString(this->location);
1266          this->__isset.location = true;
1267        } else {
1268          xfer += iprot->skip(ftype);
1269        }
1270        break;
1271      case 3:
1272        if (ftype == ::apache::thrift::protocol::T_STRING) {
1273          xfer += iprot->readString(this->inputFormat);
1274          this->__isset.inputFormat = true;
1275        } else {
1276          xfer += iprot->skip(ftype);
1277        }
1278        break;
1279      case 4:
1280        if (ftype == ::apache::thrift::protocol::T_STRING) {
1281          xfer += iprot->readString(this->outputFormat);
1282          this->__isset.outputFormat = true;
1283        } else {
1284          xfer += iprot->skip(ftype);
1285        }
1286        break;
1287      case 5:
1288        if (ftype == ::apache::thrift::protocol::T_BOOL) {
1289          xfer += iprot->readBool(this->compressed);
1290          this->__isset.compressed = true;
1291        } else {
1292          xfer += iprot->skip(ftype);
1293        }
1294        break;
1295      case 6:
1296        if (ftype == ::apache::thrift::protocol::T_I32) {
1297          xfer += iprot->readI32(this->numBuckets);
1298          this->__isset.numBuckets = true;
1299        } else {
1300          xfer += iprot->skip(ftype);
1301        }
1302        break;
1303      case 7:
1304        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
1305          xfer += this->serdeInfo.read(iprot);
1306          this->__isset.serdeInfo = true;
1307        } else {
1308          xfer += iprot->skip(ftype);
1309        }
1310        break;
1311      case 8:
1312        if (ftype == ::apache::thrift::protocol::T_LIST) {
1313          {
1314            this->bucketCols.clear();
1315            uint32_t _size84;
1316            ::apache::thrift::protocol::TType _etype87;
1317            iprot->readListBegin(_etype87, _size84);
1318            this->bucketCols.resize(_size84);
1319            uint32_t _i88;
1320            for (_i88 = 0; _i88 < _size84; ++_i88)
1321            {
1322              xfer += iprot->readString(this->bucketCols[_i88]);
1323            }
1324            iprot->readListEnd();
1325          }
1326          this->__isset.bucketCols = true;
1327        } else {
1328          xfer += iprot->skip(ftype);
1329        }
1330        break;
1331      case 9:
1332        if (ftype == ::apache::thrift::protocol::T_LIST) {
1333          {
1334            this->sortCols.clear();
1335            uint32_t _size89;
1336            ::apache::thrift::protocol::TType _etype92;
1337            iprot->readListBegin(_etype92, _size89);
1338            this->sortCols.resize(_size89);
1339            uint32_t _i93;
1340            for (_i93 = 0; _i93 < _size89; ++_i93)
1341            {
1342              xfer += this->sortCols[_i93].read(iprot);
1343            }
1344            iprot->readListEnd();
1345          }
1346          this->__isset.sortCols = true;
1347        } else {
1348          xfer += iprot->skip(ftype);
1349        }
1350        break;
1351      case 10:
1352        if (ftype == ::apache::thrift::protocol::T_MAP) {
1353          {
1354            this->parameters.clear();
1355            uint32_t _size94;
1356            ::apache::thrift::protocol::TType _ktype95;
1357            ::apache::thrift::protocol::TType _vtype96;
1358            iprot->readMapBegin(_ktype95, _vtype96, _size94);
1359            uint32_t _i98;
1360            for (_i98 = 0; _i98 < _size94; ++_i98)
1361            {
1362              std::string _key99;
1363              xfer += iprot->readString(_key99);
1364              std::string& _val100 = this->parameters[_key99];
1365              xfer += iprot->readString(_val100);
1366            }
1367            iprot->readMapEnd();
1368          }
1369          this->__isset.parameters = true;
1370        } else {
1371          xfer += iprot->skip(ftype);
1372        }
1373        break;
1374      default:
1375        xfer += iprot->skip(ftype);
1376        break;
1377    }
1378    xfer += iprot->readFieldEnd();
1379  }
1380
1381  xfer += iprot->readStructEnd();
1382
1383  return xfer;
1384}
1385
1386uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) const {
1387  uint32_t xfer = 0;
1388  xfer += oprot->writeStructBegin("StorageDescriptor");
1389  xfer += oprot->writeFieldBegin("cols", ::apache::thrift::protocol::T_LIST, 1);
1390  {
1391    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, this->cols.size());
1392    std::vector<FieldSchema> ::const_iterator _iter101;
1393    for (_iter101 = this->cols.begin(); _iter101 != this->cols.end(); ++_iter101)
1394    {
1395      xfer += (*_iter101).write(oprot);
1396    }
1397    xfer += oprot->writeListEnd();
1398  }
1399  xfer += oprot->writeFieldEnd();
1400  xfer += oprot->writeFieldBegin("location", ::apache::thrift::protocol::T_STRING, 2);
1401  xfer += oprot->writeString(this->location);
1402  xfer += oprot->writeFieldEnd();
1403  xfer += oprot->writeFieldBegin("inputFormat", ::apache::thrift::protocol::T_STRING, 3);
1404  xfer += oprot->writeString(this->inputFormat);
1405  xfer += oprot->writeFieldEnd();
1406  xfer += oprot->writeFieldBegin("outputFormat", ::apache::thrift::protocol::T_STRING, 4);
1407  xfer += oprot->writeString(this->outputFormat);
1408  xfer += oprot->writeFieldEnd();
1409  xfer += oprot->writeFieldBegin("compressed", ::apache::thrift::protocol::T_BOOL, 5);
1410  xfer += oprot->writeBool(this->compressed);
1411  xfer += oprot->writeFieldEnd();
1412  xfer += oprot->writeFieldBegin("numBuckets", ::apache::thrift::protocol::T_I32, 6);
1413  xfer += oprot->writeI32(this->numBuckets);
1414  xfer += oprot->writeFieldEnd();
1415  xfer += oprot->writeFieldBegin("serdeInfo", ::apache::thrift::protocol::T_STRUCT, 7);
1416  xfer += this->serdeInfo.write(oprot);
1417  xfer += oprot->writeFieldEnd();
1418  xfer += oprot->writeFieldBegin("bucketCols", ::apache::thrift::protocol::T_LIST, 8);
1419  {
1420    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, this->bucketCols.size());
1421    std::vector<std::string> ::const_iterator _iter102;
1422    for (_iter102 = this->bucketCols.begin(); _iter102 != this->bucketCols.end(); ++_iter102)
1423    {
1424      xfer += oprot->writeString((*_iter102));
1425    }
1426    xfer += oprot->writeListEnd();
1427  }
1428  xfer += oprot->writeFieldEnd();
1429  xfer += oprot->writeFieldBegin("sortCols", ::apache::thrift::protocol::T_LIST, 9);
1430  {
1431    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, this->sortCols.size());
1432    std::vector<Order> ::const_iterator _iter103;
1433    for (_iter103 = this->sortCols.begin(); _iter103 != this->sortCols.end(); ++_iter103)
1434    {
1435      xfer += (*_iter103).write(oprot);
1436    }
1437    xfer += oprot->writeListEnd();
1438  }
1439  xfer += oprot->writeFieldEnd();
1440  xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 10);
1441  {
1442    xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, this->parameters.size());
1443    std::map<std::string, std::string> ::const_iterator _iter104;
1444    for (_iter104 = this->parameters.begin(); _iter104 != this->parameters.end(); ++_iter104)
1445    {
1446      xfer += oprot->writeString(_iter104->first);
1447      xfer += oprot->writeString(_iter104->second);
1448    }
1449    xfer += oprot->writeMapEnd();
1450  }
1451  xfer += oprot->writeFieldEnd();
1452  xfer += oprot->writeFieldStop();
1453  xfer += oprot->writeStructEnd();
1454  return xfer;
1455}
1456
1457const char* Table::ascii_fingerprint = "26BE788C09746068A2616712C9262900";
1458const uint8_t Table::binary_fingerprint[16] = {0x26,0xBE,0x78,0x8C,0x09,0x74,0x60,0x68,0xA2,0x61,0x67,0x12,0xC9,0x26,0x29,0x00};
1459
1460uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) {
1461
1462  uint32_t xfer = 0;
1463  std::string fname;
1464  ::apache::thrift::protocol::TType ftype;
1465  int16_t fid;
1466
1467  xfer += iprot->readStructBegin(fname);
1468
1469  using ::apache::thrift::protocol::TProtocolException;
1470
1471
1472  while (true)
1473  {
1474    xfer += iprot->readFieldBegin(fname, ftype, fid);
1475    if (ftype == ::apache::thrift::protocol::T_STOP) {
1476      break;
1477    }
1478    switch (fid)
1479    {
1480      case 1:
1481        if (ftype == ::apache::thrift::protocol::T_STRING) {
1482          xfer += iprot->readString(this->tableName);
1483          this->__isset.tableName = true;
1484        } else {
1485          xfer += iprot->skip(ftype);
1486        }
1487        break;
1488      case 2:
1489        if (ftype == ::apache::thrift::protocol::T_STRING) {
1490          xfer += iprot->readString(this->dbName);
1491          this->__isset.dbName = true;
1492        } else {
1493          xfer += iprot->skip(ftype);
1494        }
1495        break;
1496      case 3:
1497        if (ftype == ::apache::thrift::protocol::T_STRING) {
1498          xfer += iprot->readString(this->owner);
1499          this->__isset.owner = true;
1500        } else {
1501          xfer += iprot->skip(ftype);
1502        }
1503        break;
1504      case 4:
1505        if (ftype == ::apache::thrift::protocol::T_I32) {
1506          xfer += iprot->readI32(this->createTime);
1507          this->__isset.createTime = true;
1508        } else {
1509          xfer += iprot->skip(ftype);
1510        }
1511        break;
1512      case 5:
1513        if (ftype == ::apache::thrift::protocol::T_I32) {
1514          xfer += iprot->readI32(this->lastAccessTime);
1515          this->__isset.lastAccessTime = true;
1516        } else {
1517          xfer += iprot->skip(ftype);
1518        }
1519        break;
1520      case 6:
1521        if (ftype == ::apache::thrift::protocol::T_I32) {
1522          xfer += iprot->readI32(this->retention);
1523          this->__isset.retention = true;
1524        } else {
1525          xfer += iprot->skip(ftype);
1526        }
1527        break;
1528      case 7:
1529        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
1530          xfer += this->sd.read(iprot);
1531          this->__isset.sd = true;
1532        } else {
1533          xfer += iprot->skip(ftype);
1534        }
1535        break;
1536      case 8:
1537        if (ftype == ::apache::thrift::protocol::T_LIST) {
1538          {
1539            this->partitionKeys.clear();
1540            uint32_t _size105;
1541            ::apache::thrift::protocol

Large files files are truncated, but you can click here to view the full file