You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by sp...@apache.org on 2018/05/05 12:42:53 UTC
[1/4] hive git commit: HIVE-19371: Add table ownerType to HMS thrift
API (Sergio Pena, reviewed by Sahil Takiar, Vihang Karajgaonkar)
Repository: hive
Updated Branches:
refs/heads/master 52f1b2471 -> a84fff8ab
http://git-wip-us.apache.org/repos/asf/hive/blob/a84fff8a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
index 4dad6dd..7b42182 100644
--- a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
+++ b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
@@ -3041,7 +3041,7 @@ inline std::ostream& operator<<(std::ostream& out, const StorageDescriptor& obj)
}
typedef struct _Table__isset {
- _Table__isset() : tableName(false), dbName(false), owner(false), createTime(false), lastAccessTime(false), retention(false), sd(false), partitionKeys(false), parameters(false), viewOriginalText(false), viewExpandedText(false), tableType(false), privileges(false), temporary(true), rewriteEnabled(false), creationMetadata(false), catName(false) {}
+ _Table__isset() : tableName(false), dbName(false), owner(false), createTime(false), lastAccessTime(false), retention(false), sd(false), partitionKeys(false), parameters(false), viewOriginalText(false), viewExpandedText(false), tableType(false), privileges(false), temporary(true), rewriteEnabled(false), creationMetadata(false), catName(false), ownerType(true) {}
bool tableName :1;
bool dbName :1;
bool owner :1;
@@ -3059,6 +3059,7 @@ typedef struct _Table__isset {
bool rewriteEnabled :1;
bool creationMetadata :1;
bool catName :1;
+ bool ownerType :1;
} _Table__isset;
class Table {
@@ -3066,7 +3067,9 @@ class Table {
Table(const Table&);
Table& operator=(const Table&);
- Table() : tableName(), dbName(), owner(), createTime(0), lastAccessTime(0), retention(0), viewOriginalText(), viewExpandedText(), tableType(), temporary(false), rewriteEnabled(0), catName() {
+ Table() : tableName(), dbName(), owner(), createTime(0), lastAccessTime(0), retention(0), viewOriginalText(), viewExpandedText(), tableType(), temporary(false), rewriteEnabled(0), catName(), ownerType((PrincipalType::type)1) {
+ ownerType = (PrincipalType::type)1;
+
}
virtual ~Table() throw();
@@ -3087,6 +3090,7 @@ class Table {
bool rewriteEnabled;
CreationMetadata creationMetadata;
std::string catName;
+ PrincipalType::type ownerType;
_Table__isset __isset;
@@ -3124,6 +3128,8 @@ class Table {
void __set_catName(const std::string& val);
+ void __set_ownerType(const PrincipalType::type val);
+
bool operator == (const Table & rhs) const
{
if (!(tableName == rhs.tableName))
@@ -3170,6 +3176,10 @@ class Table {
return false;
else if (__isset.catName && !(catName == rhs.catName))
return false;
+ if (__isset.ownerType != rhs.__isset.ownerType)
+ return false;
+ else if (__isset.ownerType && !(ownerType == rhs.ownerType))
+ return false;
return true;
}
bool operator != (const Table &rhs) const {
http://git-wip-us.apache.org/repos/asf/hive/blob/a84fff8a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Table.java
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Table.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Table.java
index 8dfec98..38d4f64 100644
--- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Table.java
+++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Table.java
@@ -55,6 +55,7 @@ import org.slf4j.LoggerFactory;
private static final org.apache.thrift.protocol.TField REWRITE_ENABLED_FIELD_DESC = new org.apache.thrift.protocol.TField("rewriteEnabled", org.apache.thrift.protocol.TType.BOOL, (short)15);
private static final org.apache.thrift.protocol.TField CREATION_METADATA_FIELD_DESC = new org.apache.thrift.protocol.TField("creationMetadata", org.apache.thrift.protocol.TType.STRUCT, (short)16);
private static final org.apache.thrift.protocol.TField CAT_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("catName", org.apache.thrift.protocol.TType.STRING, (short)17);
+ private static final org.apache.thrift.protocol.TField OWNER_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("ownerType", org.apache.thrift.protocol.TType.I32, (short)18);
private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
static {
@@ -79,6 +80,7 @@ import org.slf4j.LoggerFactory;
private boolean rewriteEnabled; // optional
private CreationMetadata creationMetadata; // optional
private String catName; // optional
+ private PrincipalType ownerType; // optional
/** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
public enum _Fields implements org.apache.thrift.TFieldIdEnum {
@@ -98,7 +100,12 @@ import org.slf4j.LoggerFactory;
TEMPORARY((short)14, "temporary"),
REWRITE_ENABLED((short)15, "rewriteEnabled"),
CREATION_METADATA((short)16, "creationMetadata"),
- CAT_NAME((short)17, "catName");
+ CAT_NAME((short)17, "catName"),
+ /**
+ *
+ * @see PrincipalType
+ */
+ OWNER_TYPE((short)18, "ownerType");
private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
@@ -147,6 +154,8 @@ import org.slf4j.LoggerFactory;
return CREATION_METADATA;
case 17: // CAT_NAME
return CAT_NAME;
+ case 18: // OWNER_TYPE
+ return OWNER_TYPE;
default:
return null;
}
@@ -193,7 +202,7 @@ import org.slf4j.LoggerFactory;
private static final int __TEMPORARY_ISSET_ID = 3;
private static final int __REWRITEENABLED_ISSET_ID = 4;
private byte __isset_bitfield = 0;
- private static final _Fields optionals[] = {_Fields.PRIVILEGES,_Fields.TEMPORARY,_Fields.REWRITE_ENABLED,_Fields.CREATION_METADATA,_Fields.CAT_NAME};
+ private static final _Fields optionals[] = {_Fields.PRIVILEGES,_Fields.TEMPORARY,_Fields.REWRITE_ENABLED,_Fields.CREATION_METADATA,_Fields.CAT_NAME,_Fields.OWNER_TYPE};
public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
static {
Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
@@ -234,6 +243,8 @@ import org.slf4j.LoggerFactory;
new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT , "CreationMetadata")));
tmpMap.put(_Fields.CAT_NAME, new org.apache.thrift.meta_data.FieldMetaData("catName", org.apache.thrift.TFieldRequirementType.OPTIONAL,
new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.OWNER_TYPE, new org.apache.thrift.meta_data.FieldMetaData("ownerType", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, PrincipalType.class)));
metaDataMap = Collections.unmodifiableMap(tmpMap);
org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(Table.class, metaDataMap);
}
@@ -241,6 +252,8 @@ import org.slf4j.LoggerFactory;
public Table() {
this.temporary = false;
+ this.ownerType = org.apache.hadoop.hive.metastore.api.PrincipalType.USER;
+
}
public Table(
@@ -326,6 +339,9 @@ import org.slf4j.LoggerFactory;
if (other.isSetCatName()) {
this.catName = other.catName;
}
+ if (other.isSetOwnerType()) {
+ this.ownerType = other.ownerType;
+ }
}
public Table deepCopy() {
@@ -356,6 +372,8 @@ import org.slf4j.LoggerFactory;
this.rewriteEnabled = false;
this.creationMetadata = null;
this.catName = null;
+ this.ownerType = org.apache.hadoop.hive.metastore.api.PrincipalType.USER;
+
}
public String getTableName() {
@@ -770,6 +788,37 @@ import org.slf4j.LoggerFactory;
}
}
+ /**
+ *
+ * @see PrincipalType
+ */
+ public PrincipalType getOwnerType() {
+ return this.ownerType;
+ }
+
+ /**
+ *
+ * @see PrincipalType
+ */
+ public void setOwnerType(PrincipalType ownerType) {
+ this.ownerType = ownerType;
+ }
+
+ public void unsetOwnerType() {
+ this.ownerType = null;
+ }
+
+ /** Returns true if field ownerType is set (has been assigned a value) and false otherwise */
+ public boolean isSetOwnerType() {
+ return this.ownerType != null;
+ }
+
+ public void setOwnerTypeIsSet(boolean value) {
+ if (!value) {
+ this.ownerType = null;
+ }
+ }
+
public void setFieldValue(_Fields field, Object value) {
switch (field) {
case TABLE_NAME:
@@ -908,6 +957,14 @@ import org.slf4j.LoggerFactory;
}
break;
+ case OWNER_TYPE:
+ if (value == null) {
+ unsetOwnerType();
+ } else {
+ setOwnerType((PrincipalType)value);
+ }
+ break;
+
}
}
@@ -964,6 +1021,9 @@ import org.slf4j.LoggerFactory;
case CAT_NAME:
return getCatName();
+ case OWNER_TYPE:
+ return getOwnerType();
+
}
throw new IllegalStateException();
}
@@ -1009,6 +1069,8 @@ import org.slf4j.LoggerFactory;
return isSetCreationMetadata();
case CAT_NAME:
return isSetCatName();
+ case OWNER_TYPE:
+ return isSetOwnerType();
}
throw new IllegalStateException();
}
@@ -1179,6 +1241,15 @@ import org.slf4j.LoggerFactory;
return false;
}
+ boolean this_present_ownerType = true && this.isSetOwnerType();
+ boolean that_present_ownerType = true && that.isSetOwnerType();
+ if (this_present_ownerType || that_present_ownerType) {
+ if (!(this_present_ownerType && that_present_ownerType))
+ return false;
+ if (!this.ownerType.equals(that.ownerType))
+ return false;
+ }
+
return true;
}
@@ -1271,6 +1342,11 @@ import org.slf4j.LoggerFactory;
if (present_catName)
list.add(catName);
+ boolean present_ownerType = true && (isSetOwnerType());
+ list.add(present_ownerType);
+ if (present_ownerType)
+ list.add(ownerType.getValue());
+
return list.hashCode();
}
@@ -1452,6 +1528,16 @@ import org.slf4j.LoggerFactory;
return lastComparison;
}
}
+ lastComparison = Boolean.valueOf(isSetOwnerType()).compareTo(other.isSetOwnerType());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetOwnerType()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ownerType, other.ownerType);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
return 0;
}
@@ -1597,6 +1683,16 @@ import org.slf4j.LoggerFactory;
}
first = false;
}
+ if (isSetOwnerType()) {
+ if (!first) sb.append(", ");
+ sb.append("ownerType:");
+ if (this.ownerType == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.ownerType);
+ }
+ first = false;
+ }
sb.append(")");
return sb.toString();
}
@@ -1810,6 +1906,14 @@ import org.slf4j.LoggerFactory;
org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
}
break;
+ case 18: // OWNER_TYPE
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.ownerType = org.apache.hadoop.hive.metastore.api.PrincipalType.findByValue(iprot.readI32());
+ struct.setOwnerTypeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
default:
org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
}
@@ -1923,6 +2027,13 @@ import org.slf4j.LoggerFactory;
oprot.writeFieldEnd();
}
}
+ if (struct.ownerType != null) {
+ if (struct.isSetOwnerType()) {
+ oprot.writeFieldBegin(OWNER_TYPE_FIELD_DESC);
+ oprot.writeI32(struct.ownerType.getValue());
+ oprot.writeFieldEnd();
+ }
+ }
oprot.writeFieldStop();
oprot.writeStructEnd();
}
@@ -1992,7 +2103,10 @@ import org.slf4j.LoggerFactory;
if (struct.isSetCatName()) {
optionals.set(16);
}
- oprot.writeBitSet(optionals, 17);
+ if (struct.isSetOwnerType()) {
+ optionals.set(17);
+ }
+ oprot.writeBitSet(optionals, 18);
if (struct.isSetTableName()) {
oprot.writeString(struct.tableName);
}
@@ -2057,12 +2171,15 @@ import org.slf4j.LoggerFactory;
if (struct.isSetCatName()) {
oprot.writeString(struct.catName);
}
+ if (struct.isSetOwnerType()) {
+ oprot.writeI32(struct.ownerType.getValue());
+ }
}
@Override
public void read(org.apache.thrift.protocol.TProtocol prot, Table struct) throws org.apache.thrift.TException {
TTupleProtocol iprot = (TTupleProtocol) prot;
- BitSet incoming = iprot.readBitSet(17);
+ BitSet incoming = iprot.readBitSet(18);
if (incoming.get(0)) {
struct.tableName = iprot.readString();
struct.setTableNameIsSet(true);
@@ -2155,6 +2272,10 @@ import org.slf4j.LoggerFactory;
struct.catName = iprot.readString();
struct.setCatNameIsSet(true);
}
+ if (incoming.get(17)) {
+ struct.ownerType = org.apache.hadoop.hive.metastore.api.PrincipalType.findByValue(iprot.readI32());
+ struct.setOwnerTypeIsSet(true);
+ }
}
}
http://git-wip-us.apache.org/repos/asf/hive/blob/a84fff8a/standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php b/standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php
index f7e7349..353c0de 100644
--- a/standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php
+++ b/standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php
@@ -6387,6 +6387,10 @@ class Table {
* @var string
*/
public $catName = null;
+ /**
+ * @var int
+ */
+ public $ownerType = 1;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
@@ -6475,6 +6479,10 @@ class Table {
'var' => 'catName',
'type' => TType::STRING,
),
+ 18 => array(
+ 'var' => 'ownerType',
+ 'type' => TType::I32,
+ ),
);
}
if (is_array($vals)) {
@@ -6529,6 +6537,9 @@ class Table {
if (isset($vals['catName'])) {
$this->catName = $vals['catName'];
}
+ if (isset($vals['ownerType'])) {
+ $this->ownerType = $vals['ownerType'];
+ }
}
}
@@ -6697,6 +6708,13 @@ class Table {
$xfer += $input->skip($ftype);
}
break;
+ case 18:
+ if ($ftype == TType::I32) {
+ $xfer += $input->readI32($this->ownerType);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
default:
$xfer += $input->skip($ftype);
break;
@@ -6829,6 +6847,11 @@ class Table {
$xfer += $output->writeString($this->catName);
$xfer += $output->writeFieldEnd();
}
+ if ($this->ownerType !== null) {
+ $xfer += $output->writeFieldBegin('ownerType', TType::I32, 18);
+ $xfer += $output->writeI32($this->ownerType);
+ $xfer += $output->writeFieldEnd();
+ }
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
http://git-wip-us.apache.org/repos/asf/hive/blob/a84fff8a/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py b/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py
index 2a3305c..fdec32e 100644
--- a/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py
+++ b/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py
@@ -4457,6 +4457,7 @@ class Table:
- rewriteEnabled
- creationMetadata
- catName
+ - ownerType
"""
thrift_spec = (
@@ -4478,9 +4479,10 @@ class Table:
(15, TType.BOOL, 'rewriteEnabled', None, None, ), # 15
(16, TType.STRUCT, 'creationMetadata', (CreationMetadata, CreationMetadata.thrift_spec), None, ), # 16
(17, TType.STRING, 'catName', None, None, ), # 17
+ (18, TType.I32, 'ownerType', None, 1, ), # 18
)
- def __init__(self, tableName=None, dbName=None, owner=None, createTime=None, lastAccessTime=None, retention=None, sd=None, partitionKeys=None, parameters=None, viewOriginalText=None, viewExpandedText=None, tableType=None, privileges=None, temporary=thrift_spec[14][4], rewriteEnabled=None, creationMetadata=None, catName=None,):
+ def __init__(self, tableName=None, dbName=None, owner=None, createTime=None, lastAccessTime=None, retention=None, sd=None, partitionKeys=None, parameters=None, viewOriginalText=None, viewExpandedText=None, tableType=None, privileges=None, temporary=thrift_spec[14][4], rewriteEnabled=None, creationMetadata=None, catName=None, ownerType=thrift_spec[18][4],):
self.tableName = tableName
self.dbName = dbName
self.owner = owner
@@ -4498,6 +4500,7 @@ class Table:
self.rewriteEnabled = rewriteEnabled
self.creationMetadata = creationMetadata
self.catName = catName
+ self.ownerType = ownerType
def read(self, iprot):
if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
@@ -4608,6 +4611,11 @@ class Table:
self.catName = iprot.readString()
else:
iprot.skip(ftype)
+ elif fid == 18:
+ if ftype == TType.I32:
+ self.ownerType = iprot.readI32()
+ else:
+ iprot.skip(ftype)
else:
iprot.skip(ftype)
iprot.readFieldEnd()
@@ -4693,6 +4701,10 @@ class Table:
oprot.writeFieldBegin('catName', TType.STRING, 17)
oprot.writeString(self.catName)
oprot.writeFieldEnd()
+ if self.ownerType is not None:
+ oprot.writeFieldBegin('ownerType', TType.I32, 18)
+ oprot.writeI32(self.ownerType)
+ oprot.writeFieldEnd()
oprot.writeFieldStop()
oprot.writeStructEnd()
@@ -4719,6 +4731,7 @@ class Table:
value = (value * 31) ^ hash(self.rewriteEnabled)
value = (value * 31) ^ hash(self.creationMetadata)
value = (value * 31) ^ hash(self.catName)
+ value = (value * 31) ^ hash(self.ownerType)
return value
def __repr__(self):
http://git-wip-us.apache.org/repos/asf/hive/blob/a84fff8a/standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb b/standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb
index fec7cde..fb73b28 100644
--- a/standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb
+++ b/standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb
@@ -1041,6 +1041,7 @@ class Table
REWRITEENABLED = 15
CREATIONMETADATA = 16
CATNAME = 17
+ OWNERTYPE = 18
FIELDS = {
TABLENAME => {:type => ::Thrift::Types::STRING, :name => 'tableName'},
@@ -1059,12 +1060,16 @@ class Table
TEMPORARY => {:type => ::Thrift::Types::BOOL, :name => 'temporary', :default => false, :optional => true},
REWRITEENABLED => {:type => ::Thrift::Types::BOOL, :name => 'rewriteEnabled', :optional => true},
CREATIONMETADATA => {:type => ::Thrift::Types::STRUCT, :name => 'creationMetadata', :class => ::CreationMetadata, :optional => true},
- CATNAME => {:type => ::Thrift::Types::STRING, :name => 'catName', :optional => true}
+ CATNAME => {:type => ::Thrift::Types::STRING, :name => 'catName', :optional => true},
+ OWNERTYPE => {:type => ::Thrift::Types::I32, :name => 'ownerType', :default => 1, :optional => true, :enum_class => ::PrincipalType}
}
def struct_fields; FIELDS; end
def validate
+ unless @ownerType.nil? || ::PrincipalType::VALID_VALUES.include?(@ownerType)
+ raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Invalid value of field ownerType!')
+ end
end
::Thrift::Struct.generate_accessors self
http://git-wip-us.apache.org/repos/asf/hive/blob/a84fff8a/standalone-metastore/src/main/thrift/hive_metastore.thrift
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/main/thrift/hive_metastore.thrift b/standalone-metastore/src/main/thrift/hive_metastore.thrift
index 38edfa4..9dc6030 100644
--- a/standalone-metastore/src/main/thrift/hive_metastore.thrift
+++ b/standalone-metastore/src/main/thrift/hive_metastore.thrift
@@ -423,7 +423,8 @@ struct Table {
14: optional bool temporary=false,
15: optional bool rewriteEnabled, // rewrite enabled or not
16: optional CreationMetadata creationMetadata, // only for MVs, it stores table names used and txn list at MV creation
- 17: optional string catName // Name of the catalog the table is in
+ 17: optional string catName, // Name of the catalog the table is in
+ 18: optional PrincipalType ownerType = PrincipalType.USER // owner type of this table (default to USER for backward compatibility)
}
struct Partition {
[3/4] hive git commit: HIVE-19371: Add table ownerType to HMS thrift
API (Sergio Pena, reviewed by Sahil Takiar, Vihang Karajgaonkar)
Posted by sp...@apache.org.
http://git-wip-us.apache.org/repos/asf/hive/blob/a84fff8a/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp b/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp
index 81ae327..3cbabf9 100644
--- a/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp
+++ b/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp
@@ -2107,14 +2107,14 @@ uint32_t ThriftHiveMetastore_get_databases_result::read(::apache::thrift::protoc
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size1199;
- ::apache::thrift::protocol::TType _etype1202;
- xfer += iprot->readListBegin(_etype1202, _size1199);
- this->success.resize(_size1199);
- uint32_t _i1203;
- for (_i1203 = 0; _i1203 < _size1199; ++_i1203)
+ uint32_t _size1200;
+ ::apache::thrift::protocol::TType _etype1203;
+ xfer += iprot->readListBegin(_etype1203, _size1200);
+ this->success.resize(_size1200);
+ uint32_t _i1204;
+ for (_i1204 = 0; _i1204 < _size1200; ++_i1204)
{
- xfer += iprot->readString(this->success[_i1203]);
+ xfer += iprot->readString(this->success[_i1204]);
}
xfer += iprot->readListEnd();
}
@@ -2153,10 +2153,10 @@ uint32_t ThriftHiveMetastore_get_databases_result::write(::apache::thrift::proto
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
- std::vector<std::string> ::const_iterator _iter1204;
- for (_iter1204 = this->success.begin(); _iter1204 != this->success.end(); ++_iter1204)
+ std::vector<std::string> ::const_iterator _iter1205;
+ for (_iter1205 = this->success.begin(); _iter1205 != this->success.end(); ++_iter1205)
{
- xfer += oprot->writeString((*_iter1204));
+ xfer += oprot->writeString((*_iter1205));
}
xfer += oprot->writeListEnd();
}
@@ -2201,14 +2201,14 @@ uint32_t ThriftHiveMetastore_get_databases_presult::read(::apache::thrift::proto
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size1205;
- ::apache::thrift::protocol::TType _etype1208;
- xfer += iprot->readListBegin(_etype1208, _size1205);
- (*(this->success)).resize(_size1205);
- uint32_t _i1209;
- for (_i1209 = 0; _i1209 < _size1205; ++_i1209)
+ uint32_t _size1206;
+ ::apache::thrift::protocol::TType _etype1209;
+ xfer += iprot->readListBegin(_etype1209, _size1206);
+ (*(this->success)).resize(_size1206);
+ uint32_t _i1210;
+ for (_i1210 = 0; _i1210 < _size1206; ++_i1210)
{
- xfer += iprot->readString((*(this->success))[_i1209]);
+ xfer += iprot->readString((*(this->success))[_i1210]);
}
xfer += iprot->readListEnd();
}
@@ -2325,14 +2325,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::read(::apache::thrift::pr
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size1210;
- ::apache::thrift::protocol::TType _etype1213;
- xfer += iprot->readListBegin(_etype1213, _size1210);
- this->success.resize(_size1210);
- uint32_t _i1214;
- for (_i1214 = 0; _i1214 < _size1210; ++_i1214)
+ uint32_t _size1211;
+ ::apache::thrift::protocol::TType _etype1214;
+ xfer += iprot->readListBegin(_etype1214, _size1211);
+ this->success.resize(_size1211);
+ uint32_t _i1215;
+ for (_i1215 = 0; _i1215 < _size1211; ++_i1215)
{
- xfer += iprot->readString(this->success[_i1214]);
+ xfer += iprot->readString(this->success[_i1215]);
}
xfer += iprot->readListEnd();
}
@@ -2371,10 +2371,10 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::write(::apache::thrift::p
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
- std::vector<std::string> ::const_iterator _iter1215;
- for (_iter1215 = this->success.begin(); _iter1215 != this->success.end(); ++_iter1215)
+ std::vector<std::string> ::const_iterator _iter1216;
+ for (_iter1216 = this->success.begin(); _iter1216 != this->success.end(); ++_iter1216)
{
- xfer += oprot->writeString((*_iter1215));
+ xfer += oprot->writeString((*_iter1216));
}
xfer += oprot->writeListEnd();
}
@@ -2419,14 +2419,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_presult::read(::apache::thrift::p
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size1216;
- ::apache::thrift::protocol::TType _etype1219;
- xfer += iprot->readListBegin(_etype1219, _size1216);
- (*(this->success)).resize(_size1216);
- uint32_t _i1220;
- for (_i1220 = 0; _i1220 < _size1216; ++_i1220)
+ uint32_t _size1217;
+ ::apache::thrift::protocol::TType _etype1220;
+ xfer += iprot->readListBegin(_etype1220, _size1217);
+ (*(this->success)).resize(_size1217);
+ uint32_t _i1221;
+ for (_i1221 = 0; _i1221 < _size1217; ++_i1221)
{
- xfer += iprot->readString((*(this->success))[_i1220]);
+ xfer += iprot->readString((*(this->success))[_i1221]);
}
xfer += iprot->readListEnd();
}
@@ -3488,17 +3488,17 @@ uint32_t ThriftHiveMetastore_get_type_all_result::read(::apache::thrift::protoco
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->success.clear();
- uint32_t _size1221;
- ::apache::thrift::protocol::TType _ktype1222;
- ::apache::thrift::protocol::TType _vtype1223;
- xfer += iprot->readMapBegin(_ktype1222, _vtype1223, _size1221);
- uint32_t _i1225;
- for (_i1225 = 0; _i1225 < _size1221; ++_i1225)
+ uint32_t _size1222;
+ ::apache::thrift::protocol::TType _ktype1223;
+ ::apache::thrift::protocol::TType _vtype1224;
+ xfer += iprot->readMapBegin(_ktype1223, _vtype1224, _size1222);
+ uint32_t _i1226;
+ for (_i1226 = 0; _i1226 < _size1222; ++_i1226)
{
- std::string _key1226;
- xfer += iprot->readString(_key1226);
- Type& _val1227 = this->success[_key1226];
- xfer += _val1227.read(iprot);
+ std::string _key1227;
+ xfer += iprot->readString(_key1227);
+ Type& _val1228 = this->success[_key1227];
+ xfer += _val1228.read(iprot);
}
xfer += iprot->readMapEnd();
}
@@ -3537,11 +3537,11 @@ uint32_t ThriftHiveMetastore_get_type_all_result::write(::apache::thrift::protoc
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::map<std::string, Type> ::const_iterator _iter1228;
- for (_iter1228 = this->success.begin(); _iter1228 != this->success.end(); ++_iter1228)
+ std::map<std::string, Type> ::const_iterator _iter1229;
+ for (_iter1229 = this->success.begin(); _iter1229 != this->success.end(); ++_iter1229)
{
- xfer += oprot->writeString(_iter1228->first);
- xfer += _iter1228->second.write(oprot);
+ xfer += oprot->writeString(_iter1229->first);
+ xfer += _iter1229->second.write(oprot);
}
xfer += oprot->writeMapEnd();
}
@@ -3586,17 +3586,17 @@ uint32_t ThriftHiveMetastore_get_type_all_presult::read(::apache::thrift::protoc
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
(*(this->success)).clear();
- uint32_t _size1229;
- ::apache::thrift::protocol::TType _ktype1230;
- ::apache::thrift::protocol::TType _vtype1231;
- xfer += iprot->readMapBegin(_ktype1230, _vtype1231, _size1229);
- uint32_t _i1233;
- for (_i1233 = 0; _i1233 < _size1229; ++_i1233)
+ uint32_t _size1230;
+ ::apache::thrift::protocol::TType _ktype1231;
+ ::apache::thrift::protocol::TType _vtype1232;
+ xfer += iprot->readMapBegin(_ktype1231, _vtype1232, _size1230);
+ uint32_t _i1234;
+ for (_i1234 = 0; _i1234 < _size1230; ++_i1234)
{
- std::string _key1234;
- xfer += iprot->readString(_key1234);
- Type& _val1235 = (*(this->success))[_key1234];
- xfer += _val1235.read(iprot);
+ std::string _key1235;
+ xfer += iprot->readString(_key1235);
+ Type& _val1236 = (*(this->success))[_key1235];
+ xfer += _val1236.read(iprot);
}
xfer += iprot->readMapEnd();
}
@@ -3750,14 +3750,14 @@ uint32_t ThriftHiveMetastore_get_fields_result::read(::apache::thrift::protocol:
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size1236;
- ::apache::thrift::protocol::TType _etype1239;
- xfer += iprot->readListBegin(_etype1239, _size1236);
- this->success.resize(_size1236);
- uint32_t _i1240;
- for (_i1240 = 0; _i1240 < _size1236; ++_i1240)
+ uint32_t _size1237;
+ ::apache::thrift::protocol::TType _etype1240;
+ xfer += iprot->readListBegin(_etype1240, _size1237);
+ this->success.resize(_size1237);
+ uint32_t _i1241;
+ for (_i1241 = 0; _i1241 < _size1237; ++_i1241)
{
- xfer += this->success[_i1240].read(iprot);
+ xfer += this->success[_i1241].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -3812,10 +3812,10 @@ uint32_t ThriftHiveMetastore_get_fields_result::write(::apache::thrift::protocol
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::vector<FieldSchema> ::const_iterator _iter1241;
- for (_iter1241 = this->success.begin(); _iter1241 != this->success.end(); ++_iter1241)
+ std::vector<FieldSchema> ::const_iterator _iter1242;
+ for (_iter1242 = this->success.begin(); _iter1242 != this->success.end(); ++_iter1242)
{
- xfer += (*_iter1241).write(oprot);
+ xfer += (*_iter1242).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -3868,14 +3868,14 @@ uint32_t ThriftHiveMetastore_get_fields_presult::read(::apache::thrift::protocol
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size1242;
- ::apache::thrift::protocol::TType _etype1245;
- xfer += iprot->readListBegin(_etype1245, _size1242);
- (*(this->success)).resize(_size1242);
- uint32_t _i1246;
- for (_i1246 = 0; _i1246 < _size1242; ++_i1246)
+ uint32_t _size1243;
+ ::apache::thrift::protocol::TType _etype1246;
+ xfer += iprot->readListBegin(_etype1246, _size1243);
+ (*(this->success)).resize(_size1243);
+ uint32_t _i1247;
+ for (_i1247 = 0; _i1247 < _size1243; ++_i1247)
{
- xfer += (*(this->success))[_i1246].read(iprot);
+ xfer += (*(this->success))[_i1247].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -4061,14 +4061,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::read(::
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size1247;
- ::apache::thrift::protocol::TType _etype1250;
- xfer += iprot->readListBegin(_etype1250, _size1247);
- this->success.resize(_size1247);
- uint32_t _i1251;
- for (_i1251 = 0; _i1251 < _size1247; ++_i1251)
+ uint32_t _size1248;
+ ::apache::thrift::protocol::TType _etype1251;
+ xfer += iprot->readListBegin(_etype1251, _size1248);
+ this->success.resize(_size1248);
+ uint32_t _i1252;
+ for (_i1252 = 0; _i1252 < _size1248; ++_i1252)
{
- xfer += this->success[_i1251].read(iprot);
+ xfer += this->success[_i1252].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -4123,10 +4123,10 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::write(:
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::vector<FieldSchema> ::const_iterator _iter1252;
- for (_iter1252 = this->success.begin(); _iter1252 != this->success.end(); ++_iter1252)
+ std::vector<FieldSchema> ::const_iterator _iter1253;
+ for (_iter1253 = this->success.begin(); _iter1253 != this->success.end(); ++_iter1253)
{
- xfer += (*_iter1252).write(oprot);
+ xfer += (*_iter1253).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4179,14 +4179,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_presult::read(:
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size1253;
- ::apache::thrift::protocol::TType _etype1256;
- xfer += iprot->readListBegin(_etype1256, _size1253);
- (*(this->success)).resize(_size1253);
- uint32_t _i1257;
- for (_i1257 = 0; _i1257 < _size1253; ++_i1257)
+ uint32_t _size1254;
+ ::apache::thrift::protocol::TType _etype1257;
+ xfer += iprot->readListBegin(_etype1257, _size1254);
+ (*(this->success)).resize(_size1254);
+ uint32_t _i1258;
+ for (_i1258 = 0; _i1258 < _size1254; ++_i1258)
{
- xfer += (*(this->success))[_i1257].read(iprot);
+ xfer += (*(this->success))[_i1258].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -4356,14 +4356,14 @@ uint32_t ThriftHiveMetastore_get_schema_result::read(::apache::thrift::protocol:
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size1258;
- ::apache::thrift::protocol::TType _etype1261;
- xfer += iprot->readListBegin(_etype1261, _size1258);
- this->success.resize(_size1258);
- uint32_t _i1262;
- for (_i1262 = 0; _i1262 < _size1258; ++_i1262)
+ uint32_t _size1259;
+ ::apache::thrift::protocol::TType _etype1262;
+ xfer += iprot->readListBegin(_etype1262, _size1259);
+ this->success.resize(_size1259);
+ uint32_t _i1263;
+ for (_i1263 = 0; _i1263 < _size1259; ++_i1263)
{
- xfer += this->success[_i1262].read(iprot);
+ xfer += this->success[_i1263].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -4418,10 +4418,10 @@ uint32_t ThriftHiveMetastore_get_schema_result::write(::apache::thrift::protocol
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::vector<FieldSchema> ::const_iterator _iter1263;
- for (_iter1263 = this->success.begin(); _iter1263 != this->success.end(); ++_iter1263)
+ std::vector<FieldSchema> ::const_iterator _iter1264;
+ for (_iter1264 = this->success.begin(); _iter1264 != this->success.end(); ++_iter1264)
{
- xfer += (*_iter1263).write(oprot);
+ xfer += (*_iter1264).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4474,14 +4474,14 @@ uint32_t ThriftHiveMetastore_get_schema_presult::read(::apache::thrift::protocol
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size1264;
- ::apache::thrift::protocol::TType _etype1267;
- xfer += iprot->readListBegin(_etype1267, _size1264);
- (*(this->success)).resize(_size1264);
- uint32_t _i1268;
- for (_i1268 = 0; _i1268 < _size1264; ++_i1268)
+ uint32_t _size1265;
+ ::apache::thrift::protocol::TType _etype1268;
+ xfer += iprot->readListBegin(_etype1268, _size1265);
+ (*(this->success)).resize(_size1265);
+ uint32_t _i1269;
+ for (_i1269 = 0; _i1269 < _size1265; ++_i1269)
{
- xfer += (*(this->success))[_i1268].read(iprot);
+ xfer += (*(this->success))[_i1269].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -4667,14 +4667,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::read(::
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size1269;
- ::apache::thrift::protocol::TType _etype1272;
- xfer += iprot->readListBegin(_etype1272, _size1269);
- this->success.resize(_size1269);
- uint32_t _i1273;
- for (_i1273 = 0; _i1273 < _size1269; ++_i1273)
+ uint32_t _size1270;
+ ::apache::thrift::protocol::TType _etype1273;
+ xfer += iprot->readListBegin(_etype1273, _size1270);
+ this->success.resize(_size1270);
+ uint32_t _i1274;
+ for (_i1274 = 0; _i1274 < _size1270; ++_i1274)
{
- xfer += this->success[_i1273].read(iprot);
+ xfer += this->success[_i1274].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -4729,10 +4729,10 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::write(:
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::vector<FieldSchema> ::const_iterator _iter1274;
- for (_iter1274 = this->success.begin(); _iter1274 != this->success.end(); ++_iter1274)
+ std::vector<FieldSchema> ::const_iterator _iter1275;
+ for (_iter1275 = this->success.begin(); _iter1275 != this->success.end(); ++_iter1275)
{
- xfer += (*_iter1274).write(oprot);
+ xfer += (*_iter1275).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4785,14 +4785,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_presult::read(:
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size1275;
- ::apache::thrift::protocol::TType _etype1278;
- xfer += iprot->readListBegin(_etype1278, _size1275);
- (*(this->success)).resize(_size1275);
- uint32_t _i1279;
- for (_i1279 = 0; _i1279 < _size1275; ++_i1279)
+ uint32_t _size1276;
+ ::apache::thrift::protocol::TType _etype1279;
+ xfer += iprot->readListBegin(_etype1279, _size1276);
+ (*(this->success)).resize(_size1276);
+ uint32_t _i1280;
+ for (_i1280 = 0; _i1280 < _size1276; ++_i1280)
{
- xfer += (*(this->success))[_i1279].read(iprot);
+ xfer += (*(this->success))[_i1280].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -5385,14 +5385,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache::
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->primaryKeys.clear();
- uint32_t _size1280;
- ::apache::thrift::protocol::TType _etype1283;
- xfer += iprot->readListBegin(_etype1283, _size1280);
- this->primaryKeys.resize(_size1280);
- uint32_t _i1284;
- for (_i1284 = 0; _i1284 < _size1280; ++_i1284)
+ uint32_t _size1281;
+ ::apache::thrift::protocol::TType _etype1284;
+ xfer += iprot->readListBegin(_etype1284, _size1281);
+ this->primaryKeys.resize(_size1281);
+ uint32_t _i1285;
+ for (_i1285 = 0; _i1285 < _size1281; ++_i1285)
{
- xfer += this->primaryKeys[_i1284].read(iprot);
+ xfer += this->primaryKeys[_i1285].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -5405,14 +5405,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache::
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->foreignKeys.clear();
- uint32_t _size1285;
- ::apache::thrift::protocol::TType _etype1288;
- xfer += iprot->readListBegin(_etype1288, _size1285);
- this->foreignKeys.resize(_size1285);
- uint32_t _i1289;
- for (_i1289 = 0; _i1289 < _size1285; ++_i1289)
+ uint32_t _size1286;
+ ::apache::thrift::protocol::TType _etype1289;
+ xfer += iprot->readListBegin(_etype1289, _size1286);
+ this->foreignKeys.resize(_size1286);
+ uint32_t _i1290;
+ for (_i1290 = 0; _i1290 < _size1286; ++_i1290)
{
- xfer += this->foreignKeys[_i1289].read(iprot);
+ xfer += this->foreignKeys[_i1290].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -5425,14 +5425,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache::
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->uniqueConstraints.clear();
- uint32_t _size1290;
- ::apache::thrift::protocol::TType _etype1293;
- xfer += iprot->readListBegin(_etype1293, _size1290);
- this->uniqueConstraints.resize(_size1290);
- uint32_t _i1294;
- for (_i1294 = 0; _i1294 < _size1290; ++_i1294)
+ uint32_t _size1291;
+ ::apache::thrift::protocol::TType _etype1294;
+ xfer += iprot->readListBegin(_etype1294, _size1291);
+ this->uniqueConstraints.resize(_size1291);
+ uint32_t _i1295;
+ for (_i1295 = 0; _i1295 < _size1291; ++_i1295)
{
- xfer += this->uniqueConstraints[_i1294].read(iprot);
+ xfer += this->uniqueConstraints[_i1295].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -5445,14 +5445,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache::
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->notNullConstraints.clear();
- uint32_t _size1295;
- ::apache::thrift::protocol::TType _etype1298;
- xfer += iprot->readListBegin(_etype1298, _size1295);
- this->notNullConstraints.resize(_size1295);
- uint32_t _i1299;
- for (_i1299 = 0; _i1299 < _size1295; ++_i1299)
+ uint32_t _size1296;
+ ::apache::thrift::protocol::TType _etype1299;
+ xfer += iprot->readListBegin(_etype1299, _size1296);
+ this->notNullConstraints.resize(_size1296);
+ uint32_t _i1300;
+ for (_i1300 = 0; _i1300 < _size1296; ++_i1300)
{
- xfer += this->notNullConstraints[_i1299].read(iprot);
+ xfer += this->notNullConstraints[_i1300].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -5465,14 +5465,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache::
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->defaultConstraints.clear();
- uint32_t _size1300;
- ::apache::thrift::protocol::TType _etype1303;
- xfer += iprot->readListBegin(_etype1303, _size1300);
- this->defaultConstraints.resize(_size1300);
- uint32_t _i1304;
- for (_i1304 = 0; _i1304 < _size1300; ++_i1304)
+ uint32_t _size1301;
+ ::apache::thrift::protocol::TType _etype1304;
+ xfer += iprot->readListBegin(_etype1304, _size1301);
+ this->defaultConstraints.resize(_size1301);
+ uint32_t _i1305;
+ for (_i1305 = 0; _i1305 < _size1301; ++_i1305)
{
- xfer += this->defaultConstraints[_i1304].read(iprot);
+ xfer += this->defaultConstraints[_i1305].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -5485,14 +5485,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache::
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->checkConstraints.clear();
- uint32_t _size1305;
- ::apache::thrift::protocol::TType _etype1308;
- xfer += iprot->readListBegin(_etype1308, _size1305);
- this->checkConstraints.resize(_size1305);
- uint32_t _i1309;
- for (_i1309 = 0; _i1309 < _size1305; ++_i1309)
+ uint32_t _size1306;
+ ::apache::thrift::protocol::TType _etype1309;
+ xfer += iprot->readListBegin(_etype1309, _size1306);
+ this->checkConstraints.resize(_size1306);
+ uint32_t _i1310;
+ for (_i1310 = 0; _i1310 < _size1306; ++_i1310)
{
- xfer += this->checkConstraints[_i1309].read(iprot);
+ xfer += this->checkConstraints[_i1310].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -5525,10 +5525,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache:
xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->primaryKeys.size()));
- std::vector<SQLPrimaryKey> ::const_iterator _iter1310;
- for (_iter1310 = this->primaryKeys.begin(); _iter1310 != this->primaryKeys.end(); ++_iter1310)
+ std::vector<SQLPrimaryKey> ::const_iterator _iter1311;
+ for (_iter1311 = this->primaryKeys.begin(); _iter1311 != this->primaryKeys.end(); ++_iter1311)
{
- xfer += (*_iter1310).write(oprot);
+ xfer += (*_iter1311).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -5537,10 +5537,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache:
xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->foreignKeys.size()));
- std::vector<SQLForeignKey> ::const_iterator _iter1311;
- for (_iter1311 = this->foreignKeys.begin(); _iter1311 != this->foreignKeys.end(); ++_iter1311)
+ std::vector<SQLForeignKey> ::const_iterator _iter1312;
+ for (_iter1312 = this->foreignKeys.begin(); _iter1312 != this->foreignKeys.end(); ++_iter1312)
{
- xfer += (*_iter1311).write(oprot);
+ xfer += (*_iter1312).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -5549,10 +5549,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache:
xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 4);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->uniqueConstraints.size()));
- std::vector<SQLUniqueConstraint> ::const_iterator _iter1312;
- for (_iter1312 = this->uniqueConstraints.begin(); _iter1312 != this->uniqueConstraints.end(); ++_iter1312)
+ std::vector<SQLUniqueConstraint> ::const_iterator _iter1313;
+ for (_iter1313 = this->uniqueConstraints.begin(); _iter1313 != this->uniqueConstraints.end(); ++_iter1313)
{
- xfer += (*_iter1312).write(oprot);
+ xfer += (*_iter1313).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -5561,10 +5561,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache:
xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 5);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->notNullConstraints.size()));
- std::vector<SQLNotNullConstraint> ::const_iterator _iter1313;
- for (_iter1313 = this->notNullConstraints.begin(); _iter1313 != this->notNullConstraints.end(); ++_iter1313)
+ std::vector<SQLNotNullConstraint> ::const_iterator _iter1314;
+ for (_iter1314 = this->notNullConstraints.begin(); _iter1314 != this->notNullConstraints.end(); ++_iter1314)
{
- xfer += (*_iter1313).write(oprot);
+ xfer += (*_iter1314).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -5573,10 +5573,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache:
xfer += oprot->writeFieldBegin("defaultConstraints", ::apache::thrift::protocol::T_LIST, 6);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->defaultConstraints.size()));
- std::vector<SQLDefaultConstraint> ::const_iterator _iter1314;
- for (_iter1314 = this->defaultConstraints.begin(); _iter1314 != this->defaultConstraints.end(); ++_iter1314)
+ std::vector<SQLDefaultConstraint> ::const_iterator _iter1315;
+ for (_iter1315 = this->defaultConstraints.begin(); _iter1315 != this->defaultConstraints.end(); ++_iter1315)
{
- xfer += (*_iter1314).write(oprot);
+ xfer += (*_iter1315).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -5585,10 +5585,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache:
xfer += oprot->writeFieldBegin("checkConstraints", ::apache::thrift::protocol::T_LIST, 7);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->checkConstraints.size()));
- std::vector<SQLCheckConstraint> ::const_iterator _iter1315;
- for (_iter1315 = this->checkConstraints.begin(); _iter1315 != this->checkConstraints.end(); ++_iter1315)
+ std::vector<SQLCheckConstraint> ::const_iterator _iter1316;
+ for (_iter1316 = this->checkConstraints.begin(); _iter1316 != this->checkConstraints.end(); ++_iter1316)
{
- xfer += (*_iter1315).write(oprot);
+ xfer += (*_iter1316).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -5616,10 +5616,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache
xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->primaryKeys)).size()));
- std::vector<SQLPrimaryKey> ::const_iterator _iter1316;
- for (_iter1316 = (*(this->primaryKeys)).begin(); _iter1316 != (*(this->primaryKeys)).end(); ++_iter1316)
+ std::vector<SQLPrimaryKey> ::const_iterator _iter1317;
+ for (_iter1317 = (*(this->primaryKeys)).begin(); _iter1317 != (*(this->primaryKeys)).end(); ++_iter1317)
{
- xfer += (*_iter1316).write(oprot);
+ xfer += (*_iter1317).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -5628,10 +5628,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache
xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->foreignKeys)).size()));
- std::vector<SQLForeignKey> ::const_iterator _iter1317;
- for (_iter1317 = (*(this->foreignKeys)).begin(); _iter1317 != (*(this->foreignKeys)).end(); ++_iter1317)
+ std::vector<SQLForeignKey> ::const_iterator _iter1318;
+ for (_iter1318 = (*(this->foreignKeys)).begin(); _iter1318 != (*(this->foreignKeys)).end(); ++_iter1318)
{
- xfer += (*_iter1317).write(oprot);
+ xfer += (*_iter1318).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -5640,10 +5640,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache
xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 4);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->uniqueConstraints)).size()));
- std::vector<SQLUniqueConstraint> ::const_iterator _iter1318;
- for (_iter1318 = (*(this->uniqueConstraints)).begin(); _iter1318 != (*(this->uniqueConstraints)).end(); ++_iter1318)
+ std::vector<SQLUniqueConstraint> ::const_iterator _iter1319;
+ for (_iter1319 = (*(this->uniqueConstraints)).begin(); _iter1319 != (*(this->uniqueConstraints)).end(); ++_iter1319)
{
- xfer += (*_iter1318).write(oprot);
+ xfer += (*_iter1319).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -5652,10 +5652,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache
xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 5);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->notNullConstraints)).size()));
- std::vector<SQLNotNullConstraint> ::const_iterator _iter1319;
- for (_iter1319 = (*(this->notNullConstraints)).begin(); _iter1319 != (*(this->notNullConstraints)).end(); ++_iter1319)
+ std::vector<SQLNotNullConstraint> ::const_iterator _iter1320;
+ for (_iter1320 = (*(this->notNullConstraints)).begin(); _iter1320 != (*(this->notNullConstraints)).end(); ++_iter1320)
{
- xfer += (*_iter1319).write(oprot);
+ xfer += (*_iter1320).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -5664,10 +5664,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache
xfer += oprot->writeFieldBegin("defaultConstraints", ::apache::thrift::protocol::T_LIST, 6);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->defaultConstraints)).size()));
- std::vector<SQLDefaultConstraint> ::const_iterator _iter1320;
- for (_iter1320 = (*(this->defaultConstraints)).begin(); _iter1320 != (*(this->defaultConstraints)).end(); ++_iter1320)
+ std::vector<SQLDefaultConstraint> ::const_iterator _iter1321;
+ for (_iter1321 = (*(this->defaultConstraints)).begin(); _iter1321 != (*(this->defaultConstraints)).end(); ++_iter1321)
{
- xfer += (*_iter1320).write(oprot);
+ xfer += (*_iter1321).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -5676,10 +5676,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache
xfer += oprot->writeFieldBegin("checkConstraints", ::apache::thrift::protocol::T_LIST, 7);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->checkConstraints)).size()));
- std::vector<SQLCheckConstraint> ::const_iterator _iter1321;
- for (_iter1321 = (*(this->checkConstraints)).begin(); _iter1321 != (*(this->checkConstraints)).end(); ++_iter1321)
+ std::vector<SQLCheckConstraint> ::const_iterator _iter1322;
+ for (_iter1322 = (*(this->checkConstraints)).begin(); _iter1322 != (*(this->checkConstraints)).end(); ++_iter1322)
{
- xfer += (*_iter1321).write(oprot);
+ xfer += (*_iter1322).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -7847,14 +7847,14 @@ uint32_t ThriftHiveMetastore_truncate_table_args::read(::apache::thrift::protoco
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partNames.clear();
- uint32_t _size1322;
- ::apache::thrift::protocol::TType _etype1325;
- xfer += iprot->readListBegin(_etype1325, _size1322);
- this->partNames.resize(_size1322);
- uint32_t _i1326;
- for (_i1326 = 0; _i1326 < _size1322; ++_i1326)
+ uint32_t _size1323;
+ ::apache::thrift::protocol::TType _etype1326;
+ xfer += iprot->readListBegin(_etype1326, _size1323);
+ this->partNames.resize(_size1323);
+ uint32_t _i1327;
+ for (_i1327 = 0; _i1327 < _size1323; ++_i1327)
{
- xfer += iprot->readString(this->partNames[_i1326]);
+ xfer += iprot->readString(this->partNames[_i1327]);
}
xfer += iprot->readListEnd();
}
@@ -7891,10 +7891,10 @@ uint32_t ThriftHiveMetastore_truncate_table_args::write(::apache::thrift::protoc
xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partNames.size()));
- std::vector<std::string> ::const_iterator _iter1327;
- for (_iter1327 = this->partNames.begin(); _iter1327 != this->partNames.end(); ++_iter1327)
+ std::vector<std::string> ::const_iterator _iter1328;
+ for (_iter1328 = this->partNames.begin(); _iter1328 != this->partNames.end(); ++_iter1328)
{
- xfer += oprot->writeString((*_iter1327));
+ xfer += oprot->writeString((*_iter1328));
}
xfer += oprot->writeListEnd();
}
@@ -7926,10 +7926,10 @@ uint32_t ThriftHiveMetastore_truncate_table_pargs::write(::apache::thrift::proto
xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->partNames)).size()));
- std::vector<std::string> ::const_iterator _iter1328;
- for (_iter1328 = (*(this->partNames)).begin(); _iter1328 != (*(this->partNames)).end(); ++_iter1328)
+ std::vector<std::string> ::const_iterator _iter1329;
+ for (_iter1329 = (*(this->partNames)).begin(); _iter1329 != (*(this->partNames)).end(); ++_iter1329)
{
- xfer += oprot->writeString((*_iter1328));
+ xfer += oprot->writeString((*_iter1329));
}
xfer += oprot->writeListEnd();
}
@@ -8173,14 +8173,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol:
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size1329;
- ::apache::thrift::protocol::TType _etype1332;
- xfer += iprot->readListBegin(_etype1332, _size1329);
- this->success.resize(_size1329);
- uint32_t _i1333;
- for (_i1333 = 0; _i1333 < _size1329; ++_i1333)
+ uint32_t _size1330;
+ ::apache::thrift::protocol::TType _etype1333;
+ xfer += iprot->readListBegin(_etype1333, _size1330);
+ this->success.resize(_size1330);
+ uint32_t _i1334;
+ for (_i1334 = 0; _i1334 < _size1330; ++_i1334)
{
- xfer += iprot->readString(this->success[_i1333]);
+ xfer += iprot->readString(this->success[_i1334]);
}
xfer += iprot->readListEnd();
}
@@ -8219,10 +8219,10 @@ uint32_t ThriftHiveMetastore_get_tables_result::write(::apache::thrift::protocol
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
- std::vector<std::string> ::const_iterator _iter1334;
- for (_iter1334 = this->success.begin(); _iter1334 != this->success.end(); ++_iter1334)
+ std::vector<std::string> ::const_iterator _iter1335;
+ for (_iter1335 = this->success.begin(); _iter1335 != this->success.end(); ++_iter1335)
{
- xfer += oprot->writeString((*_iter1334));
+ xfer += oprot->writeString((*_iter1335));
}
xfer += oprot->writeListEnd();
}
@@ -8267,14 +8267,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size1335;
- ::apache::thrift::protocol::TType _etype1338;
- xfer += iprot->readListBegin(_etype1338, _size1335);
- (*(this->success)).resize(_size1335);
- uint32_t _i1339;
- for (_i1339 = 0; _i1339 < _size1335; ++_i1339)
+ uint32_t _size1336;
+ ::apache::thrift::protocol::TType _etype1339;
+ xfer += iprot->readListBegin(_etype1339, _size1336);
+ (*(this->success)).resize(_size1336);
+ uint32_t _i1340;
+ for (_i1340 = 0; _i1340 < _size1336; ++_i1340)
{
- xfer += iprot->readString((*(this->success))[_i1339]);
+ xfer += iprot->readString((*(this->success))[_i1340]);
}
xfer += iprot->readListEnd();
}
@@ -8444,14 +8444,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::read(::apache::thrift::p
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size1340;
- ::apache::thrift::protocol::TType _etype1343;
- xfer += iprot->readListBegin(_etype1343, _size1340);
- this->success.resize(_size1340);
- uint32_t _i1344;
- for (_i1344 = 0; _i1344 < _size1340; ++_i1344)
+ uint32_t _size1341;
+ ::apache::thrift::protocol::TType _etype1344;
+ xfer += iprot->readListBegin(_etype1344, _size1341);
+ this->success.resize(_size1341);
+ uint32_t _i1345;
+ for (_i1345 = 0; _i1345 < _size1341; ++_i1345)
{
- xfer += iprot->readString(this->success[_i1344]);
+ xfer += iprot->readString(this->success[_i1345]);
}
xfer += iprot->readListEnd();
}
@@ -8490,10 +8490,10 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::write(::apache::thrift::
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
- std::vector<std::string> ::const_iterator _iter1345;
- for (_iter1345 = this->success.begin(); _iter1345 != this->success.end(); ++_iter1345)
+ std::vector<std::string> ::const_iterator _iter1346;
+ for (_iter1346 = this->success.begin(); _iter1346 != this->success.end(); ++_iter1346)
{
- xfer += oprot->writeString((*_iter1345));
+ xfer += oprot->writeString((*_iter1346));
}
xfer += oprot->writeListEnd();
}
@@ -8538,14 +8538,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift::
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size1346;
- ::apache::thrift::protocol::TType _etype1349;
- xfer += iprot->readListBegin(_etype1349, _size1346);
- (*(this->success)).resize(_size1346);
- uint32_t _i1350;
- for (_i1350 = 0; _i1350 < _size1346; ++_i1350)
+ uint32_t _size1347;
+ ::apache::thrift::protocol::TType _etype1350;
+ xfer += iprot->readListBegin(_etype1350, _size1347);
+ (*(this->success)).resize(_size1347);
+ uint32_t _i1351;
+ for (_i1351 = 0; _i1351 < _size1347; ++_i1351)
{
- xfer += iprot->readString((*(this->success))[_i1350]);
+ xfer += iprot->readString((*(this->success))[_i1351]);
}
xfer += iprot->readListEnd();
}
@@ -8683,14 +8683,14 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_result::read(:
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size1351;
- ::apache::thrift::protocol::TType _etype1354;
- xfer += iprot->readListBegin(_etype1354, _size1351);
- this->success.resize(_size1351);
- uint32_t _i1355;
- for (_i1355 = 0; _i1355 < _size1351; ++_i1355)
+ uint32_t _size1352;
+ ::apache::thrift::protocol::TType _etype1355;
+ xfer += iprot->readListBegin(_etype1355, _size1352);
+ this->success.resize(_size1352);
+ uint32_t _i1356;
+ for (_i1356 = 0; _i1356 < _size1352; ++_i1356)
{
- xfer += iprot->readString(this->success[_i1355]);
+ xfer += iprot->readString(this->success[_i1356]);
}
xfer += iprot->readListEnd();
}
@@ -8729,10 +8729,10 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_result::write(
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
- std::vector<std::string> ::const_iterator _iter1356;
- for (_iter1356 = this->success.begin(); _iter1356 != this->success.end(); ++_iter1356)
+ std::vector<std::string> ::const_iterator _iter1357;
+ for (_iter1357 = this->success.begin(); _iter1357 != this->success.end(); ++_iter1357)
{
- xfer += oprot->writeString((*_iter1356));
+ xfer += oprot->writeString((*_iter1357));
}
xfer += oprot->writeListEnd();
}
@@ -8777,14 +8777,14 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_presult::read(
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size1357;
- ::apache::thrift::protocol::TType _etype1360;
- xfer += iprot->readListBegin(_etype1360, _size1357);
- (*(this->success)).resize(_size1357);
- uint32_t _i1361;
- for (_i1361 = 0; _i1361 < _size1357; ++_i1361)
+ uint32_t _size1358;
+ ::apache::thrift::protocol::TType _etype1361;
+ xfer += iprot->readListBegin(_etype1361, _size1358);
+ (*(this->success)).resize(_size1358);
+ uint32_t _i1362;
+ for (_i1362 = 0; _i1362 < _size1358; ++_i1362)
{
- xfer += iprot->readString((*(this->success))[_i1361]);
+ xfer += iprot->readString((*(this->success))[_i1362]);
}
xfer += iprot->readListEnd();
}
@@ -8859,14 +8859,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::read(::apache::thrift::protoco
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->tbl_types.clear();
- uint32_t _size1362;
- ::apache::thrift::protocol::TType _etype1365;
- xfer += iprot->readListBegin(_etype1365, _size1362);
- this->tbl_types.resize(_size1362);
- uint32_t _i1366;
- for (_i1366 = 0; _i1366 < _size1362; ++_i1366)
+ uint32_t _size1363;
+ ::apache::thrift::protocol::TType _etype1366;
+ xfer += iprot->readListBegin(_etype1366, _size1363);
+ this->tbl_types.resize(_size1363);
+ uint32_t _i1367;
+ for (_i1367 = 0; _i1367 < _size1363; ++_i1367)
{
- xfer += iprot->readString(this->tbl_types[_i1366]);
+ xfer += iprot->readString(this->tbl_types[_i1367]);
}
xfer += iprot->readListEnd();
}
@@ -8903,10 +8903,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::write(::apache::thrift::protoc
xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tbl_types.size()));
- std::vector<std::string> ::const_iterator _iter1367;
- for (_iter1367 = this->tbl_types.begin(); _iter1367 != this->tbl_types.end(); ++_iter1367)
+ std::vector<std::string> ::const_iterator _iter1368;
+ for (_iter1368 = this->tbl_types.begin(); _iter1368 != this->tbl_types.end(); ++_iter1368)
{
- xfer += oprot->writeString((*_iter1367));
+ xfer += oprot->writeString((*_iter1368));
}
xfer += oprot->writeListEnd();
}
@@ -8938,10 +8938,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_pargs::write(::apache::thrift::proto
xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->tbl_types)).size()));
- std::vector<std::string> ::const_iterator _iter1368;
- for (_iter1368 = (*(this->tbl_types)).begin(); _iter1368 != (*(this->tbl_types)).end(); ++_iter1368)
+ std::vector<std::string> ::const_iterator _iter1369;
+ for (_iter1369 = (*(this->tbl_types)).begin(); _iter1369 != (*(this->tbl_types)).end(); ++_iter1369)
{
- xfer += oprot->writeString((*_iter1368));
+ xfer += oprot->writeString((*_iter1369));
}
xfer += oprot->writeListEnd();
}
@@ -8982,14 +8982,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size1369;
- ::apache::thrift::protocol::TType _etype1372;
- xfer += iprot->readListBegin(_etype1372, _size1369);
- this->success.resize(_size1369);
- uint32_t _i1373;
- for (_i1373 = 0; _i1373 < _size1369; ++_i1373)
+ uint32_t _size1370;
+ ::apache::thrift::protocol::TType _etype1373;
+ xfer += iprot->readListBegin(_etype1373, _size1370);
+ this->success.resize(_size1370);
+ uint32_t _i1374;
+ for (_i1374 = 0; _i1374 < _size1370; ++_i1374)
{
- xfer += this->success[_i1373].read(iprot);
+ xfer += this->success[_i1374].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -9028,10 +9028,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::write(::apache::thrift::prot
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::vector<TableMeta> ::const_iterator _iter1374;
- for (_iter1374 = this->success.begin(); _iter1374 != this->success.end(); ++_iter1374)
+ std::vector<TableMeta> ::const_iterator _iter1375;
+ for (_iter1375 = this->success.begin(); _iter1375 != this->success.end(); ++_iter1375)
{
- xfer += (*_iter1374).write(oprot);
+ xfer += (*_iter1375).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -9076,14 +9076,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size1375;
- ::apache::thrift::protocol::TType _etype1378;
- xfer += iprot->readListBegin(_etype1378, _size1375);
- (*(this->success)).resize(_size1375);
- uint32_t _i1379;
- for (_i1379 = 0; _i1379 < _size1375; ++_i1379)
+ uint32_t _size1376;
+ ::apache::thrift::protocol::TType _etype1379;
+ xfer += iprot->readListBegin(_etype1379, _size1376);
+ (*(this->success)).resize(_size1376);
+ uint32_t _i1380;
+ for (_i1380 = 0; _i1380 < _size1376; ++_i1380)
{
- xfer += (*(this->success))[_i1379].read(iprot);
+ xfer += (*(this->success))[_i1380].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -9221,14 +9221,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size1380;
- ::apache::thrift::protocol::TType _etype1383;
- xfer += iprot->readListBegin(_etype1383, _size1380);
- this->success.resize(_size1380);
- uint32_t _i1384;
- for (_i1384 = 0; _i1384 < _size1380; ++_i1384)
+ uint32_t _size1381;
+ ::apache::thrift::protocol::TType _etype1384;
+ xfer += iprot->readListBegin(_etype1384, _size1381);
+ this->success.resize(_size1381);
+ uint32_t _i1385;
+ for (_i1385 = 0; _i1385 < _size1381; ++_i1385)
{
- xfer += iprot->readString(this->success[_i1384]);
+ xfer += iprot->readString(this->success[_i1385]);
}
xfer += iprot->readListEnd();
}
@@ -9267,10 +9267,10 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::write(::apache::thrift::prot
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
- std::vector<std::string> ::const_iterator _iter1385;
- for (_iter1385 = this->success.begin(); _iter1385 != this->success.end(); ++_iter1385)
+ std::vector<std::string> ::const_iterator _iter1386;
+ for (_iter1386 = this->success.begin(); _iter1386 != this->success.end(); ++_iter1386)
{
- xfer += oprot->writeString((*_iter1385));
+ xfer += oprot->writeString((*_iter1386));
}
xfer += oprot->writeListEnd();
}
@@ -9315,14 +9315,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size1386;
- ::apache::thrift::protocol::TType _etype1389;
- xfer += iprot->readListBegin(_etype1389, _size1386);
- (*(this->success)).resize(_size1386);
- uint32_t _i1390;
- for (_i1390 = 0; _i1390 < _size1386; ++_i1390)
+ uint32_t _size1387;
+ ::apache::thrift::protocol::TType _etype1390;
+ xfer += iprot->readListBegin(_etype1390, _size1387);
+ (*(this->success)).resize(_size1387);
+ uint32_t _i1391;
+ for (_i1391 = 0; _i1391 < _size1387; ++_i1391)
{
- xfer += iprot->readString((*(this->success))[_i1390]);
+ xfer += iprot->readString((*(this->success))[_i1391]);
}
xfer += iprot->readListEnd();
}
@@ -9632,14 +9632,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_args::read(::apache::thri
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->tbl_names.clear();
- uint32_t _size1391;
- ::apache::thrift::protocol::TType _etype1394;
- xfer += iprot->readListBegin(_etype1394, _size1391);
- this->tbl_names.resize(_size1391);
- uint32_t _i1395;
- for (_i1395 = 0; _i1395 < _size1391; ++_i1395)
+ uint32_t _size1392;
+ ::apache::thrift::protocol::TType _etype1395;
+ xfer += iprot->readListBegin(_etype1395, _size1392);
+ this->tbl_names.resize(_size1392);
+ uint32_t _i1396;
+ for (_i1396 = 0; _i1396 < _size1392; ++_i1396)
{
- xfer += iprot->readString(this->tbl_names[_i1395]);
+ xfer += iprot->readString(this->tbl_names[_i1396]);
}
xfer += iprot->readListEnd();
}
@@ -9672,10 +9672,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_args::write(::apache::thr
xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tbl_names.size()));
- std::vector<std::string> ::const_iterator _iter1396;
- for (_iter1396 = this->tbl_names.begin(); _iter1396 != this->tbl_names.end(); ++_iter1396)
+ std::vector<std::string> ::const_iterator _iter1397;
+ for (_iter1397 = this->tbl_names.begin(); _iter1397 != this->tbl_names.end(); ++_iter1397)
{
- xfer += oprot->writeString((*_iter1396));
+ xfer += oprot->writeString((*_iter1397));
}
xfer += oprot->writeListEnd();
}
@@ -9703,10 +9703,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_pargs::write(::apache::th
xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->tbl_names)).size()));
- std::vector<std::string> ::const_iterator _iter1397;
- for (_iter1397 = (*(this->tbl_names)).begin(); _iter1397 != (*(this->tbl_names)).end(); ++_iter1397)
+ std::vector<std::string> ::const_iterator _iter1398;
+ for (_iter1398 = (*(this->tbl_names)).begin(); _iter1398 != (*(this->tbl_names)).end(); ++_iter1398)
{
- xfer += oprot->writeString((*_iter1397));
+ xfer += oprot->writeString((*_iter1398));
}
xfer += oprot->writeListEnd();
}
@@ -9747,14 +9747,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_result::read(::apache::th
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size1398;
- ::apache::thrift::protocol::TType _etype1401;
- xfer += iprot->readListBegin(_etype1401, _size1398);
- this->success.resize(_size1398);
- uint32_t _i1402;
- for (_i1402 = 0; _i1402 < _size1398; ++_i1402)
+ uint32_t _size1399;
+ ::apache::thrift::protocol::TType _etype1402;
+ xfer += iprot->readListBegin(_etype1402, _size1399);
+ this->success.resize(_size1399);
+ uint32_t _i1403;
+ for (_i1403 = 0; _i1403 < _size1399; ++_i1403)
{
- xfer += this->success[_i1402].read(iprot);
+ xfer += this->success[_i1403].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -9785,10 +9785,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_result::write(::apache::t
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::vector<Table> ::const_iterator _iter1403;
- for (_iter1403 = this->success.begin(); _iter1403 != this->success.end(); ++_iter1403)
+ std::vector<Table> ::const_iterator _iter1404;
+ for (_iter1404 = this->success.begin(); _iter1404 != this->success.end(); ++_iter1404)
{
- xfer += (*_iter1403).write(oprot);
+ xfer += (*_iter1404).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -9829,14 +9829,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_presult::read(::apache::t
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size1404;
- ::apache::thrift::protocol::TType _etype1407;
- xfer += iprot->readListBegin(_etype1407, _size1404);
- (*(this->success)).resize(_size1404);
- uint32_t _i1408;
- for (_i1408 = 0; _i1408 < _size1404; ++_i1408)
+ uint32_t _size1405;
+ ::apache::thrift::protocol::TType _etype1408;
+ xfer += iprot->readListBegin(_etype1408, _size1405);
+ (*(this->success)).resize(_size1405);
+ uint32_t _i1409;
+ for (_i1409 = 0; _i1409 < _size1405; ++_i1409)
{
- xfer += (*(this->success))[_i1408].read(iprot);
+ xfer += (*(this->success))[_i1409].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -10369,14 +10369,14 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_args::read(::
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->tbl_names.clear();
- uint32_t _size1409;
- ::apache::thrift::protocol::TType _etype1412;
- xfer += iprot->readListBegin(_etype1412, _size1409);
- this->tbl_names.resize(_size1409);
- uint32_t _i1413;
- for (_i1413 = 0; _i1413 < _size1409; ++_i1413)
+ uint32_t _size1410;
+ ::apache::thrift::protocol::TType _etype1413;
+ xfer += iprot->readListBegin(_etype1413, _size1410);
+ this->tbl_names.resize(_size1410);
+ uint32_t _i1414;
+ for (_i1414 = 0; _i1414 < _size1410; ++_i1414)
{
- xfer += iprot->readString(this->tbl_names[_i1413]);
+ xfer += iprot->readString(this->tbl_names[_i1414]);
}
xfer += iprot->readListEnd();
}
@@ -10409,10 +10409,10 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_args::write(:
xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tbl_names.size()));
- std::vector<std::string> ::const_iterator _iter1414;
- for (_iter1414 = this->tbl_names.begin(); _iter1414 != this->tbl_names.end(); ++_iter1414)
+ std::vector<std::string> ::const_iterator _iter1415;
+ for (_iter1415 = this->tbl_names.begin(); _iter1415 != this->tbl_names.end(); ++_iter1415)
{
- xfer += oprot->writeString((*_iter1414));
+ xfer += oprot->writeString((*_iter1415));
}
xfer += oprot->writeListEnd();
}
@@ -10440,10 +10440,10 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_pargs::write(
xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->tbl_names)).size()));
- std::vector<std::string> ::const_iterator _iter1415;
- for (_iter1415 = (*(this->tbl_names)).begin(); _iter1415 != (*(this->tbl_names)).end(); ++_iter1415)
+ std::vector<std::string> ::const_iterator _iter1416;
+ for (_iter1416 = (*(this->tbl_names)).begin(); _iter1416 != (*(this->tbl_names)).end(); ++_iter1416)
{
- xfer += oprot->writeString((*_iter1415));
+ xfer += oprot->writeString((*_iter1416));
}
xfer += oprot->writeListEnd();
}
@@ -10484,17 +10484,17 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_result::read(
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->success.clear();
- uint32_t _size1416;
- ::apache::thrift::protocol::TType _ktype1417;
- ::apache::thrift::protocol::TType _vtype1418;
- xfer += iprot->readMapBegin(_ktype1417, _vtype1418, _size1416);
- uint32_t _i1420;
- for (_i1420 = 0; _i1420 < _size1416; ++_i1420)
+ uint32_t _size1417;
+ ::apache::thrift::protocol::TType _ktype1418;
+ ::apache::thrift::protocol::TType _vtype1419;
+ xfer += iprot->readMapBegin(_ktype1418, _vtype1419, _size1417);
+ uint32_t _i1421;
+ for (_i1421 = 0; _i1421 < _size1417; ++_i1421)
{
- std::string _key1421;
- xfer += iprot->readString(_key1421);
- Materialization& _val1422 = this->success[_key1421];
- xfer += _val1422.read(iprot);
+ std::string _key1422;
+ xfer += iprot->readString(_key1422);
+ Materialization& _val1423 = this->success[_key1422];
+ xfer += _val1423.read(iprot);
}
xfer += iprot->readMapEnd();
}
@@ -10549,11 +10549,11 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_result::write
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::map<std::string, Materialization> ::const_iterator _iter1423;
- for (_iter1423 = this->success.begin(); _iter1423 != this->success.end(); ++_iter1423)
+ std::map<std::string, Materialization> ::const_iterator _iter1424;
+ for (_iter1424 = this->success.begin(); _iter1424 != this->success.end(); ++_iter1424)
{
- xfer += oprot->writeString(_iter1423->first);
- xfer += _iter1423->second.write(oprot);
+ xfer += oprot->writeString(_iter1424->first);
+ xfer += _iter1424->second.write(oprot);
}
xfer += oprot->writeMapEnd();
}
@@ -10606,17 +10606,17 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_presult::read
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
(*(this->success)).clear();
- uint32_t _size1424;
- ::apache::thrift::protocol::TType _ktype1425;
- ::apache::thrift::protocol::TType _vtype1426;
- xfer += iprot->readMapBegin(_ktype1425, _vtype1426, _size1424);
- uint32_t _i1428;
- for (_i1428 = 0; _i1428 < _size1424; ++_i1428)
+ uint32_t _size1425;
+ ::apache::thrift::protocol::TType _ktype1426;
+ ::apache::thrift::protocol::TType _vtype1427;
+ xfer += iprot->readMapBegin(_ktype1426, _vtype1427, _size1425);
+ uint32_t _i1429;
+ for (_i1429 = 0; _i1429 < _size1425; ++_i1429)
{
- std::string _key1429;
- xfer += iprot->readString(_key1429);
- Materialization& _val1430 = (*(this->success))[_key1429];
- xfer += _val1430.read(iprot);
+ std::string _key1430;
+ xfer += iprot->readString(_key1430);
+ Materialization& _val1431 = (*(this->success))[_key1430];
+ xfer += _val1431.read(iprot);
}
xfer += iprot->readMapEnd();
}
@@ -11077,14 +11077,14 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_result::read(::apache::th
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size1431;
- ::apache::thrift::protocol::TType _etype1434;
- xfer += iprot->readListBegin(_etype1434, _size1431);
- this->success.resize(_size1431);
- uint32_t _i1435;
- for (_i1435 = 0; _i1435 < _size1431; ++_i1435)
+ uint32_t _size1432;
+ ::apache::thrift::protocol::TType _etype1435;
+ xfer += iprot->readListBegin(_etype1435, _size1432);
+ this->success.resize(_size1432);
+ uint32_t _i1436;
+ for (_i1436 = 0; _i1436 < _size1432; ++_i1436)
{
- xfer += iprot->readString(this->success[_i1435]);
+ xfer += iprot->readString(this->success[_i1436]);
}
xfer += iprot->readListEnd();
}
@@ -11139,10 +11139,10 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_result::write(::apache::t
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
- std::vector<std::string> ::const_iterator _iter1436;
- for (_iter1436 = this->success.begin(); _iter1436 != this->success.end(); ++_iter1436)
+ std::vector<std::string> ::const_iterator _iter1437;
+ for (_iter1437 = this->success.begin(); _iter1437 != this->success.end(); ++_iter1437)
{
- xfer += oprot->writeString((*_iter1436));
+ xfer += oprot->writeString((*_iter1437));
}
xfer += oprot->writeListEnd();
}
@@ -11195,14 +11195,14 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_presult::read(::apache::t
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size1437;
- ::apache::thrift::protocol::TType _etype1440;
- xfer += iprot->readListBegin(_etype1440, _size1437);
- (*(this->success)).resize(_size1437);
- uint32_t _i1441;
- for (_i1441 = 0; _i1441 < _size1437; ++_i1441)
+ uint32_t _size1438;
+ ::apache::thrift::protocol::TType _etype1441;
+ xfer += iprot->readListBegin(_etype1441, _size1438);
+ (*(this->success)).resize(_size1438);
+ uint32_t _i1442;
+ for (_i1442 = 0; _i1442 < _size1438; ++_i1442)
{
- xfer += iprot->readString((*(this->success))[_i1441]);
+ xfer += iprot->readString((*(this->success))[_i1442]);
}
xfer += iprot->readListEnd();
}
@@ -12536,14 +12536,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->new_parts.clear();
- uint32_t _size1442;
- ::apache::thrift::protocol::TType _etype1445;
- xfer += iprot->readListBegin(_etype1445, _size1442);
- this->new_parts.resize(_size1442);
- uint32_t _i1446;
- for (_i1446 = 0; _i1446 < _size1442; ++_i1446)
+ uint32_t _size1443;
+ ::apache::thrift::protocol::TType _etype1446;
+ xfer += iprot->readListBegin(_etype1446, _size1443);
+ this->new_parts.resize(_size1443);
+ uint32_t _i1447;
+ for (_i1447 = 0; _i1447 < _size1443; ++_i1447)
{
- xfer += this->new_parts[_i1446].read(iprot);
+ xfer += this->new_parts[_i1447].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -12572,10 +12572,10 @@ uint32_t ThriftHiveMetastore_add_partitions_args::write(::apache::thrift::protoc
xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->new_parts.size()));
- std::vector<Partition> ::const_iterator _iter1447;
- for (_iter1447 = this->new_parts.begin(); _iter1447 != this->new_parts.end(); ++_iter1447)
+ std::vector<Partition> ::const_iterator _iter1448;
+ for (_iter1448 = this->new_parts.begin(); _iter1448 != this->new_parts.end(); ++_iter1448)
{
- xfer += (*_iter1447).write(oprot);
+ xfer += (*_iter1448).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -12599,10 +12599,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pargs::write(::apache::thrift::proto
xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->new_parts)).size()));
- std::vector<Partition> ::const_iterator _iter1448;
- for (_iter1448 = (*(this->new_parts)).begin(); _iter1448 != (*(this->new_parts)).end(); ++_iter1448)
+ std::vector<Partition> ::const_iterator _iter1449;
+ for (_iter1449 = (*(this->new_parts)).begin(); _iter1449 != (*(this->new_parts)).end(); ++_iter1449)
{
- xfer += (*_iter1448).write(oprot);
+ xfer += (*_iter1449).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -12811,14 +12811,14 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_args::read(::apache::thrift::p
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->new_parts.clear();
- uint32_t _size1449;
- ::apache::thrift::protocol::TType _etype1452;
- xfer += iprot->readListBegin(_etype1452, _size1449);
- this->new_parts.resize(_size1449);
- uint32_t _i1453;
- for (_i1453 = 0; _i1453 < _size1449; ++_i1453)
+ uint32_t _size1450;
+ ::apache::thrift::protocol::TType _etype1453;
+ xfer += iprot->readListBegin(_etype1453, _size1450);
+ this->new_parts.resize(_size1450);
+ uint32_t _i1454;
+ for (_i1454 = 0; _i1454 < _size1450; ++_i1454)
{
- xfer += this->new_parts[_i1453].read(iprot);
+ xfer += this->new_parts[_i1454].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -12847,10 +12847,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_args::write(::apache::thrift::
xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->new_parts.size()));
- std::vector<PartitionSpec> ::const_iterator _iter1454;
- for (_iter1454 = this->new_parts.begin(); _iter1454 != this->new_parts.end(); ++_iter1454)
+ std::vector<PartitionSpec> ::const_iterator _iter1455;
+ for (_iter1455 = this->new_parts.begin(); _iter1455 != this->new_parts.end(); ++_iter1455)
{
- xfer += (*_iter1454).write(oprot);
+ xfer += (*_iter1455).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -12874,10 +12874,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_pargs::write(::apache::thrift:
xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->new_parts)).size()));
- std::vector<PartitionSpec> ::const_iterator _iter1455;
- for (_iter1455 = (*(this->new_parts)).begin(); _iter1455 != (*(this->new_parts)).end(); ++_iter1455)
+ std::vector<PartitionSpec> ::const_iterator _iter1456;
+ for (_iter1456 = (*(this->new_parts)).begin(); _iter1456 != (*(this->new_parts)).end(); ++_iter1456)
{
- xfer += (*_iter1455).write(oprot);
+ xfer += (*_iter1456).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -13102,14 +13102,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->part_vals.clear();
- uint32_t _size1456;
- ::apache::thrift::protocol::TType _etype1459;
- xfer += iprot->readListBegin(_etype1459, _size1456);
- this->part_vals.resize(_size1456);
- uint32_t _i1460;
- for (_i1460 = 0; _i1460 < _size1456; ++_i1460)
+ uint32_t _size1457;
+ ::apache::thrift::protocol::TType _etype1460;
+ xfer += iprot->readListBegin(_etype1460, _size1457);
+ this->part_vals.resize(_size1457);
+ uint32_t _i1461;
+ for (_i1461 = 0; _i1461 < _size1457; ++_i1461)
{
- xfer += iprot->readString(this->part_vals[_i1460]);
+ xfer += iprot->readString(this->part_vals[_i1461]);
}
xfer += iprot->readListEnd();
}
@@ -13146,10 +13146,10 @@ uint32_t ThriftHiveMetastore_append_partition_args::write(::apache::thrift::prot
xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size()));
- std::vector<std::string> ::const_iterator _iter1461;
- for (_iter1461 = this->part_vals.begin(); _iter1461 != this->part_vals.end(); ++_iter1461)
+ std::vector<std::string> ::const_iterator _iter1462;
+ for (_iter1462 = this->part_vals.begin(); _iter1462 != this->part_vals.end(); ++_iter1462)
{
- xfer += oprot->writeString((*_iter1461));
+ xfer += oprot->writeString((*_iter1462));
}
xfer += oprot->writeListEnd();
}
@@ -13181,10 +13181,10 @@ uint32_t ThriftHiveMetastore_append_partition_pargs::write(::apache::thrift::pro
xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size()));
- std::vector<std::string> ::const_iterator _iter1462;
- for (_iter1462 = (*(this->part_vals)).begin(); _iter1462 != (*(this->part_vals)).end(); ++_iter1462)
+ std::vector<std::string> ::const_iterator _iter1463;
+ for (_iter1463 = (*(this->part_vals)).begin(); _iter1463 != (*(this->part_vals)).end(); ++_iter1463)
{
- xfer += oprot->writeString((*_iter1462));
+ xfer += oprot->writeString((*_iter1463));
}
xfer += oprot->writeListEnd();
}
@@ -13656,14 +13656,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->part_vals.clear();
- uint32_t _size1463;
- ::apache::thrift::protocol::TType _etype1466;
- xfer += iprot->readListBegin(_etype1466, _size1463);
- this->part_vals.resize(_size1463);
- uint32_t _i1467;
- for (_i1467 = 0; _i1467 < _size1463; ++_i1467)
+ uint32_t _size1464;
+ ::apache::thrift::protocol::TType _etype1467;
+ xfer += iprot->readListBegin(_etype1467, _size1464);
+ this->part_vals.resize(_size1464);
+ uint32_t _i1468;
+ for (_i1468 = 0; _i1468 < _size1464; ++_i1468)
{
- xfer += iprot->readString(this->part_vals[_i1467]);
+ xfer += iprot->readString(this->part_vals[_i1468]);
}
xfer += iprot->readListEnd();
}
@@ -13708,10 +13708,10 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::wri
xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size()));
- std::vector<std::string> ::const_iterator _iter1468;
- for (_iter1468 = this->part_vals.begin(); _iter1468 != this->part_vals.end(); ++_iter1468)
+ std::vector<std::string> ::const_iterator _iter1469;
+ for (_iter1469 = this->part_vals.begin(); _iter1469 != this->part_vals.end(); ++_iter1469)
{
- xfer += oprot->writeString((*_iter1468));
+ xfer += oprot->writeString((*_iter1469));
}
xfer += oprot->writeListEnd();
}
@@ -13747,10 +13747,10 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_pargs::wr
xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size()));
- std::vector<std::string> ::const_iterator _iter1469;
- for (_iter1469 = (*(this->part_vals)).begin(); _iter1469 != (*(this->part_vals)).end(); ++_iter1469)
+ std::vector<std::string> ::const_iterator _iter1470;
+ for (_iter1470 = (*(this->part_vals)).begin(); _iter1470 != (*(this->part_vals)).end(); ++_iter1470)
{
- xfer += oprot->writeString((*_iter1469));
+ xfer += oprot->writeString((*_iter1470));
}
xfer += oprot->writeListEnd();
}
@@ -14553,14 +14553,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->part_vals.clear();
- uint32_t _size1470;
- ::apache::thrift::protocol::TType _etype1473;
- xfer += iprot->readListBegin(_etype1473, _size1470);
- this->part_vals.resize(_size1470);
- uint32_t _i1474;
- for (_i1474 = 0; _i1474 < _size1470; ++_i1474)
+ uint32_t _size1471;
+ ::apache::thrift::protocol::TType _etype1474;
+ xfer += iprot->readListBegin(_etype1474, _size1471);
+ this->part_vals.resize(_size1471);
+ uint32_t _i1475;
+ for (_i1475 = 0; _i1475 < _size1471; ++_i1475)
{
- xfer += iprot->readString(this->part_vals[_i1474]);
+ xfer += iprot->readString(this->part_vals[_i1475]);
}
xfer += iprot->readListEnd();
}
@@ -14605,10 +14605,10 @@ uint32_t ThriftHiveMetastore_drop_partition_args::write(::apache::thrift::protoc
xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size()));
- std::vector<std::string> ::const_iterator _iter1475;
- for (_iter1475 = this->part_vals.begin(); _iter1475 != this->part_vals.end(); ++_iter1475)
+ std::vector<std::string> ::const_iterator _iter1476;
+ for (_iter1476 = this->part_vals.begin(); _iter1476 != this->part_vals.end(); ++_iter1476)
{
- xfer += oprot->writeString((*_iter1475));
+ xfer += oprot->writeString((*_iter1476));
}
xfer += oprot->writeListEnd();
}
@@ -14644,10 +14644,10 @@ uint32_t ThriftHiveMetastore_drop_partition_pargs::write(::apache::thrift::proto
xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size()));
- std::vector<std::string> ::const_iterator _iter1476;
- for (_iter1476 = (*(this->part_vals)).begin(); _iter1476 != (*(this->part_vals)).end(); ++_iter1476)
+ std::vector<std::string> ::const_iterator _iter1477;
+ for (_iter1477 = (*(this->part_vals)).begin(); _iter1477 != (*(this->part_vals)).end(); ++_iter1477)
{
- xfer += oprot->writeString((*_iter1476));
+ xfer += oprot->writeString((*_iter1477));
}
xfer += oprot->writeListEnd();
}
@@ -14856,14 +14856,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read(
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->part_vals.clear();
- uint32_t _size1477;
- ::apache::thrift::protocol::TType _etype1480;
- xfer += iprot->readListBegin(_etype1480, _size1477);
- this->part_vals.resize(_size1477);
- uint32_t _i1481;
- for (_i1481 = 0; _i1481 < _size1477; ++_i1481)
+ uint32_t _size1478;
+ ::apache::thrift::protocol::TType _etype1481;
+ xfer += iprot->readListBegin(_etype1481, _size1478);
+ this->part_vals.resize(_size1478);
+ uint32_t _i1482;
+ for (_i1482 = 0; _i1482 < _size1478; ++_i1482)
{
- xfer += iprot->readString(this->part_vals[_i1481]);
+ xfer += iprot->readString(this->part_vals[_i1482]);
}
xfer += iprot->readListEnd();
}
@@ -14916,10 +14916,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::write
xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size()));
- std::vector<std::string> ::const_iterator _iter1482;
- for (_iter1482 = this->part_vals.begin(); _iter1482 != this->part_vals.end(); ++_iter1482)
+ std::vector<std::string> ::const_iterator _iter1483;
+ for (_iter1483 = this->part_vals.begin(); _iter1483 != this->part_vals.end(); ++_iter1483)
{
- xfer += oprot->writeString((*_iter1482));
+ xfer += oprot->writeString((*_iter1483));
}
xfer += oprot->writeListEnd();
}
@@ -14959,10 +14959,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_pargs::writ
xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size()));
- std::vector<std::string> ::const_iterator _iter1483;
- for (_iter1483 = (*(this->part_vals)).begin(); _iter1483 != (*(this->part_vals)).end(); ++_iter1483)
+ std::vector<std::string> ::const_iterator _iter1484;
+ for (_iter1484 = (*(this->part_vals)).begin(); _iter1484 != (*(this->part_vals)).end(); ++_iter1484)
{
- xfer += oprot->writeString((*_iter1483));
+ xfer += oprot->writeString((*_iter1484));
}
xfer += oprot->writeListEnd();
}
@@ -15968,14 +15968,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->part_vals.clear();
- uint32_t _size1484;
- ::apache::thrift::protocol::TType _etype1487;
- xfer += iprot->readListBegin(_etype1487, _size1484);
- this->part_vals.resize(_size1484);
- uint32_t _i1488;
- for (_i1488 = 0; _i1488 < _size1484; ++_i1488)
+ uint32_t _size1485;
+ ::apache::thrift::protocol::TType _etype1488;
+ xfer += iprot->readListBegin(_etype1488, _size1485);
+ this->part_vals.resize(_size1485);
+ uint32_t _i1489;
+ for (_i1489 = 0; _i1489 < _size1485; ++_i1489)
{
- xfer += iprot->readString(this->part_vals[_i1488]);
+ xfer += iprot->readString(this->part_vals[_i1489]);
}
xfer += iprot->readListEnd();
}
@@ -16012,10 +16012,10 @@ uint32_t ThriftHiveMetastore_get_partition_args::write(::apache::thrift::protoco
xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size()));
- std::vector<std::string> ::const_iterator _iter1489;
- for (_iter1489 = this->part_vals.begin(); _iter1489 != this->part_vals.end(); ++_iter1489)
+ std::vector<std::string> ::const_iterator _iter1490;
+ for (_iter1490 = this->part_vals.begin(); _iter1490 != this->part_vals.end(); ++_iter1490)
{
- xfer += oprot->writeString((*_iter1489));
+ xfer += oprot->writeString((*_iter1490));
}
xfer += oprot->writeListEnd();
}
@@ -16047,10 +16047,10 @@ uint32_t ThriftHiveMetastore_get_partition_pargs::write(::apache::thrift::protoc
xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size()));
- std::vector<std::string> ::const_iterator _iter1490;
- for (_iter1490 = (*(this->part_vals)).begin(); _iter1490 != (*(this->part_vals)).end(); ++_iter1490)
+ std::vector<std::string> ::const_iterator _iter1491;
+ for (_iter1491 = (*(this->part_vals)).begin(); _iter1491 != (*(this->part_vals)).end(); ++_iter1491)
{
- xfer += oprot->writeString((*_iter1490));
+ xfer += oprot->writeString((*_iter1491));
}
xfer += oprot->writeListEnd();
}
<TRUNCATED>
[4/4] hive git commit: HIVE-19371: Add table ownerType to HMS thrift
API (Sergio Pena, reviewed by Sahil Takiar, Vihang Karajgaonkar)
Posted by sp...@apache.org.
HIVE-19371: Add table ownerType to HMS thrift API (Sergio Pena, reviewed by Sahil Takiar, Vihang Karajgaonkar)
Project: http://git-wip-us.apache.org/repos/asf/hive/repo
Commit: http://git-wip-us.apache.org/repos/asf/hive/commit/a84fff8a
Tree: http://git-wip-us.apache.org/repos/asf/hive/tree/a84fff8a
Diff: http://git-wip-us.apache.org/repos/asf/hive/diff/a84fff8a
Branch: refs/heads/master
Commit: a84fff8ab6b16018ac548c56f4cec5d59748923f
Parents: 52f1b24
Author: Sergio Pena <se...@cloudera.com>
Authored: Sat May 5 07:37:55 2018 -0500
Committer: Sergio Pena <se...@cloudera.com>
Committed: Sat May 5 07:37:55 2018 -0500
----------------------------------------------------------------------
.../gen/thrift/gen-cpp/ThriftHiveMetastore.cpp | 2292 ++++-----
.../gen/thrift/gen-cpp/hive_metastore_types.cpp | 4486 +++++++++---------
.../gen/thrift/gen-cpp/hive_metastore_types.h | 14 +-
.../apache/hadoop/hive/metastore/api/Table.java | 129 +-
.../src/gen/thrift/gen-php/metastore/Types.php | 23 +
.../gen/thrift/gen-py/hive_metastore/ttypes.py | 15 +-
.../gen/thrift/gen-rb/hive_metastore_types.rb | 7 +-
.../src/main/thrift/hive_metastore.thrift | 3 +-
8 files changed, 3583 insertions(+), 3386 deletions(-)
----------------------------------------------------------------------
[2/4] hive git commit: HIVE-19371: Add table ownerType to HMS thrift
API (Sergio Pena, reviewed by Sahil Takiar, Vihang Karajgaonkar)
Posted by sp...@apache.org.
http://git-wip-us.apache.org/repos/asf/hive/blob/a84fff8a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
index 25d851b..af975fc 100644
--- a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
+++ b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
@@ -6304,6 +6304,11 @@ void Table::__set_catName(const std::string& val) {
__isset.catName = true;
}
+void Table::__set_ownerType(const PrincipalType::type val) {
+ this->ownerType = val;
+__isset.ownerType = true;
+}
+
uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) {
apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
@@ -6488,6 +6493,16 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) {
xfer += iprot->skip(ftype);
}
break;
+ case 18:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast246;
+ xfer += iprot->readI32(ecast246);
+ this->ownerType = (PrincipalType::type)ecast246;
+ this->__isset.ownerType = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
default:
xfer += iprot->skip(ftype);
break;
@@ -6536,10 +6551,10 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("partitionKeys", ::apache::thrift::protocol::T_LIST, 8);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitionKeys.size()));
- std::vector<FieldSchema> ::const_iterator _iter246;
- for (_iter246 = this->partitionKeys.begin(); _iter246 != this->partitionKeys.end(); ++_iter246)
+ std::vector<FieldSchema> ::const_iterator _iter247;
+ for (_iter247 = this->partitionKeys.begin(); _iter247 != this->partitionKeys.end(); ++_iter247)
{
- xfer += (*_iter246).write(oprot);
+ xfer += (*_iter247).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -6548,11 +6563,11 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 9);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->parameters.size()));
- std::map<std::string, std::string> ::const_iterator _iter247;
- for (_iter247 = this->parameters.begin(); _iter247 != this->parameters.end(); ++_iter247)
+ std::map<std::string, std::string> ::const_iterator _iter248;
+ for (_iter248 = this->parameters.begin(); _iter248 != this->parameters.end(); ++_iter248)
{
- xfer += oprot->writeString(_iter247->first);
- xfer += oprot->writeString(_iter247->second);
+ xfer += oprot->writeString(_iter248->first);
+ xfer += oprot->writeString(_iter248->second);
}
xfer += oprot->writeMapEnd();
}
@@ -6595,6 +6610,11 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeString(this->catName);
xfer += oprot->writeFieldEnd();
}
+ if (this->__isset.ownerType) {
+ xfer += oprot->writeFieldBegin("ownerType", ::apache::thrift::protocol::T_I32, 18);
+ xfer += oprot->writeI32((int32_t)this->ownerType);
+ xfer += oprot->writeFieldEnd();
+ }
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
return xfer;
@@ -6619,30 +6639,11 @@ void swap(Table &a, Table &b) {
swap(a.rewriteEnabled, b.rewriteEnabled);
swap(a.creationMetadata, b.creationMetadata);
swap(a.catName, b.catName);
+ swap(a.ownerType, b.ownerType);
swap(a.__isset, b.__isset);
}
-Table::Table(const Table& other248) {
- tableName = other248.tableName;
- dbName = other248.dbName;
- owner = other248.owner;
- createTime = other248.createTime;
- lastAccessTime = other248.lastAccessTime;
- retention = other248.retention;
- sd = other248.sd;
- partitionKeys = other248.partitionKeys;
- parameters = other248.parameters;
- viewOriginalText = other248.viewOriginalText;
- viewExpandedText = other248.viewExpandedText;
- tableType = other248.tableType;
- privileges = other248.privileges;
- temporary = other248.temporary;
- rewriteEnabled = other248.rewriteEnabled;
- creationMetadata = other248.creationMetadata;
- catName = other248.catName;
- __isset = other248.__isset;
-}
-Table& Table::operator=(const Table& other249) {
+Table::Table(const Table& other249) {
tableName = other249.tableName;
dbName = other249.dbName;
owner = other249.owner;
@@ -6660,7 +6661,29 @@ Table& Table::operator=(const Table& other249) {
rewriteEnabled = other249.rewriteEnabled;
creationMetadata = other249.creationMetadata;
catName = other249.catName;
+ ownerType = other249.ownerType;
__isset = other249.__isset;
+}
+Table& Table::operator=(const Table& other250) {
+ tableName = other250.tableName;
+ dbName = other250.dbName;
+ owner = other250.owner;
+ createTime = other250.createTime;
+ lastAccessTime = other250.lastAccessTime;
+ retention = other250.retention;
+ sd = other250.sd;
+ partitionKeys = other250.partitionKeys;
+ parameters = other250.parameters;
+ viewOriginalText = other250.viewOriginalText;
+ viewExpandedText = other250.viewExpandedText;
+ tableType = other250.tableType;
+ privileges = other250.privileges;
+ temporary = other250.temporary;
+ rewriteEnabled = other250.rewriteEnabled;
+ creationMetadata = other250.creationMetadata;
+ catName = other250.catName;
+ ownerType = other250.ownerType;
+ __isset = other250.__isset;
return *this;
}
void Table::printTo(std::ostream& out) const {
@@ -6683,6 +6706,7 @@ void Table::printTo(std::ostream& out) const {
out << ", " << "rewriteEnabled="; (__isset.rewriteEnabled ? (out << to_string(rewriteEnabled)) : (out << "<null>"));
out << ", " << "creationMetadata="; (__isset.creationMetadata ? (out << to_string(creationMetadata)) : (out << "<null>"));
out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "<null>"));
+ out << ", " << "ownerType="; (__isset.ownerType ? (out << to_string(ownerType)) : (out << "<null>"));
out << ")";
}
@@ -6754,14 +6778,14 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->values.clear();
- uint32_t _size250;
- ::apache::thrift::protocol::TType _etype253;
- xfer += iprot->readListBegin(_etype253, _size250);
- this->values.resize(_size250);
- uint32_t _i254;
- for (_i254 = 0; _i254 < _size250; ++_i254)
+ uint32_t _size251;
+ ::apache::thrift::protocol::TType _etype254;
+ xfer += iprot->readListBegin(_etype254, _size251);
+ this->values.resize(_size251);
+ uint32_t _i255;
+ for (_i255 = 0; _i255 < _size251; ++_i255)
{
- xfer += iprot->readString(this->values[_i254]);
+ xfer += iprot->readString(this->values[_i255]);
}
xfer += iprot->readListEnd();
}
@@ -6814,17 +6838,17 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->parameters.clear();
- uint32_t _size255;
- ::apache::thrift::protocol::TType _ktype256;
- ::apache::thrift::protocol::TType _vtype257;
- xfer += iprot->readMapBegin(_ktype256, _vtype257, _size255);
- uint32_t _i259;
- for (_i259 = 0; _i259 < _size255; ++_i259)
+ uint32_t _size256;
+ ::apache::thrift::protocol::TType _ktype257;
+ ::apache::thrift::protocol::TType _vtype258;
+ xfer += iprot->readMapBegin(_ktype257, _vtype258, _size256);
+ uint32_t _i260;
+ for (_i260 = 0; _i260 < _size256; ++_i260)
{
- std::string _key260;
- xfer += iprot->readString(_key260);
- std::string& _val261 = this->parameters[_key260];
- xfer += iprot->readString(_val261);
+ std::string _key261;
+ xfer += iprot->readString(_key261);
+ std::string& _val262 = this->parameters[_key261];
+ xfer += iprot->readString(_val262);
}
xfer += iprot->readMapEnd();
}
@@ -6869,10 +6893,10 @@ uint32_t Partition::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->values.size()));
- std::vector<std::string> ::const_iterator _iter262;
- for (_iter262 = this->values.begin(); _iter262 != this->values.end(); ++_iter262)
+ std::vector<std::string> ::const_iterator _iter263;
+ for (_iter263 = this->values.begin(); _iter263 != this->values.end(); ++_iter263)
{
- xfer += oprot->writeString((*_iter262));
+ xfer += oprot->writeString((*_iter263));
}
xfer += oprot->writeListEnd();
}
@@ -6901,11 +6925,11 @@ uint32_t Partition::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 7);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->parameters.size()));
- std::map<std::string, std::string> ::const_iterator _iter263;
- for (_iter263 = this->parameters.begin(); _iter263 != this->parameters.end(); ++_iter263)
+ std::map<std::string, std::string> ::const_iterator _iter264;
+ for (_iter264 = this->parameters.begin(); _iter264 != this->parameters.end(); ++_iter264)
{
- xfer += oprot->writeString(_iter263->first);
- xfer += oprot->writeString(_iter263->second);
+ xfer += oprot->writeString(_iter264->first);
+ xfer += oprot->writeString(_iter264->second);
}
xfer += oprot->writeMapEnd();
}
@@ -6940,19 +6964,7 @@ void swap(Partition &a, Partition &b) {
swap(a.__isset, b.__isset);
}
-Partition::Partition(const Partition& other264) {
- values = other264.values;
- dbName = other264.dbName;
- tableName = other264.tableName;
- createTime = other264.createTime;
- lastAccessTime = other264.lastAccessTime;
- sd = other264.sd;
- parameters = other264.parameters;
- privileges = other264.privileges;
- catName = other264.catName;
- __isset = other264.__isset;
-}
-Partition& Partition::operator=(const Partition& other265) {
+Partition::Partition(const Partition& other265) {
values = other265.values;
dbName = other265.dbName;
tableName = other265.tableName;
@@ -6963,6 +6975,18 @@ Partition& Partition::operator=(const Partition& other265) {
privileges = other265.privileges;
catName = other265.catName;
__isset = other265.__isset;
+}
+Partition& Partition::operator=(const Partition& other266) {
+ values = other266.values;
+ dbName = other266.dbName;
+ tableName = other266.tableName;
+ createTime = other266.createTime;
+ lastAccessTime = other266.lastAccessTime;
+ sd = other266.sd;
+ parameters = other266.parameters;
+ privileges = other266.privileges;
+ catName = other266.catName;
+ __isset = other266.__isset;
return *this;
}
void Partition::printTo(std::ostream& out) const {
@@ -7035,14 +7059,14 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->values.clear();
- uint32_t _size266;
- ::apache::thrift::protocol::TType _etype269;
- xfer += iprot->readListBegin(_etype269, _size266);
- this->values.resize(_size266);
- uint32_t _i270;
- for (_i270 = 0; _i270 < _size266; ++_i270)
+ uint32_t _size267;
+ ::apache::thrift::protocol::TType _etype270;
+ xfer += iprot->readListBegin(_etype270, _size267);
+ this->values.resize(_size267);
+ uint32_t _i271;
+ for (_i271 = 0; _i271 < _size267; ++_i271)
{
- xfer += iprot->readString(this->values[_i270]);
+ xfer += iprot->readString(this->values[_i271]);
}
xfer += iprot->readListEnd();
}
@@ -7079,17 +7103,17 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->parameters.clear();
- uint32_t _size271;
- ::apache::thrift::protocol::TType _ktype272;
- ::apache::thrift::protocol::TType _vtype273;
- xfer += iprot->readMapBegin(_ktype272, _vtype273, _size271);
- uint32_t _i275;
- for (_i275 = 0; _i275 < _size271; ++_i275)
+ uint32_t _size272;
+ ::apache::thrift::protocol::TType _ktype273;
+ ::apache::thrift::protocol::TType _vtype274;
+ xfer += iprot->readMapBegin(_ktype273, _vtype274, _size272);
+ uint32_t _i276;
+ for (_i276 = 0; _i276 < _size272; ++_i276)
{
- std::string _key276;
- xfer += iprot->readString(_key276);
- std::string& _val277 = this->parameters[_key276];
- xfer += iprot->readString(_val277);
+ std::string _key277;
+ xfer += iprot->readString(_key277);
+ std::string& _val278 = this->parameters[_key277];
+ xfer += iprot->readString(_val278);
}
xfer += iprot->readMapEnd();
}
@@ -7126,10 +7150,10 @@ uint32_t PartitionWithoutSD::write(::apache::thrift::protocol::TProtocol* oprot)
xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->values.size()));
- std::vector<std::string> ::const_iterator _iter278;
- for (_iter278 = this->values.begin(); _iter278 != this->values.end(); ++_iter278)
+ std::vector<std::string> ::const_iterator _iter279;
+ for (_iter279 = this->values.begin(); _iter279 != this->values.end(); ++_iter279)
{
- xfer += oprot->writeString((*_iter278));
+ xfer += oprot->writeString((*_iter279));
}
xfer += oprot->writeListEnd();
}
@@ -7150,11 +7174,11 @@ uint32_t PartitionWithoutSD::write(::apache::thrift::protocol::TProtocol* oprot)
xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 5);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->parameters.size()));
- std::map<std::string, std::string> ::const_iterator _iter279;
- for (_iter279 = this->parameters.begin(); _iter279 != this->parameters.end(); ++_iter279)
+ std::map<std::string, std::string> ::const_iterator _iter280;
+ for (_iter280 = this->parameters.begin(); _iter280 != this->parameters.end(); ++_iter280)
{
- xfer += oprot->writeString(_iter279->first);
- xfer += oprot->writeString(_iter279->second);
+ xfer += oprot->writeString(_iter280->first);
+ xfer += oprot->writeString(_iter280->second);
}
xfer += oprot->writeMapEnd();
}
@@ -7181,16 +7205,7 @@ void swap(PartitionWithoutSD &a, PartitionWithoutSD &b) {
swap(a.__isset, b.__isset);
}
-PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other280) {
- values = other280.values;
- createTime = other280.createTime;
- lastAccessTime = other280.lastAccessTime;
- relativePath = other280.relativePath;
- parameters = other280.parameters;
- privileges = other280.privileges;
- __isset = other280.__isset;
-}
-PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other281) {
+PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other281) {
values = other281.values;
createTime = other281.createTime;
lastAccessTime = other281.lastAccessTime;
@@ -7198,6 +7213,15 @@ PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& othe
parameters = other281.parameters;
privileges = other281.privileges;
__isset = other281.__isset;
+}
+PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other282) {
+ values = other282.values;
+ createTime = other282.createTime;
+ lastAccessTime = other282.lastAccessTime;
+ relativePath = other282.relativePath;
+ parameters = other282.parameters;
+ privileges = other282.privileges;
+ __isset = other282.__isset;
return *this;
}
void PartitionWithoutSD::printTo(std::ostream& out) const {
@@ -7250,14 +7274,14 @@ uint32_t PartitionSpecWithSharedSD::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitions.clear();
- uint32_t _size282;
- ::apache::thrift::protocol::TType _etype285;
- xfer += iprot->readListBegin(_etype285, _size282);
- this->partitions.resize(_size282);
- uint32_t _i286;
- for (_i286 = 0; _i286 < _size282; ++_i286)
+ uint32_t _size283;
+ ::apache::thrift::protocol::TType _etype286;
+ xfer += iprot->readListBegin(_etype286, _size283);
+ this->partitions.resize(_size283);
+ uint32_t _i287;
+ for (_i287 = 0; _i287 < _size283; ++_i287)
{
- xfer += this->partitions[_i286].read(iprot);
+ xfer += this->partitions[_i287].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -7294,10 +7318,10 @@ uint32_t PartitionSpecWithSharedSD::write(::apache::thrift::protocol::TProtocol*
xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size()));
- std::vector<PartitionWithoutSD> ::const_iterator _iter287;
- for (_iter287 = this->partitions.begin(); _iter287 != this->partitions.end(); ++_iter287)
+ std::vector<PartitionWithoutSD> ::const_iterator _iter288;
+ for (_iter288 = this->partitions.begin(); _iter288 != this->partitions.end(); ++_iter288)
{
- xfer += (*_iter287).write(oprot);
+ xfer += (*_iter288).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -7319,15 +7343,15 @@ void swap(PartitionSpecWithSharedSD &a, PartitionSpecWithSharedSD &b) {
swap(a.__isset, b.__isset);
}
-PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other288) {
- partitions = other288.partitions;
- sd = other288.sd;
- __isset = other288.__isset;
-}
-PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other289) {
+PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other289) {
partitions = other289.partitions;
sd = other289.sd;
__isset = other289.__isset;
+}
+PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other290) {
+ partitions = other290.partitions;
+ sd = other290.sd;
+ __isset = other290.__isset;
return *this;
}
void PartitionSpecWithSharedSD::printTo(std::ostream& out) const {
@@ -7372,14 +7396,14 @@ uint32_t PartitionListComposingSpec::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitions.clear();
- uint32_t _size290;
- ::apache::thrift::protocol::TType _etype293;
- xfer += iprot->readListBegin(_etype293, _size290);
- this->partitions.resize(_size290);
- uint32_t _i294;
- for (_i294 = 0; _i294 < _size290; ++_i294)
+ uint32_t _size291;
+ ::apache::thrift::protocol::TType _etype294;
+ xfer += iprot->readListBegin(_etype294, _size291);
+ this->partitions.resize(_size291);
+ uint32_t _i295;
+ for (_i295 = 0; _i295 < _size291; ++_i295)
{
- xfer += this->partitions[_i294].read(iprot);
+ xfer += this->partitions[_i295].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -7408,10 +7432,10 @@ uint32_t PartitionListComposingSpec::write(::apache::thrift::protocol::TProtocol
xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size()));
- std::vector<Partition> ::const_iterator _iter295;
- for (_iter295 = this->partitions.begin(); _iter295 != this->partitions.end(); ++_iter295)
+ std::vector<Partition> ::const_iterator _iter296;
+ for (_iter296 = this->partitions.begin(); _iter296 != this->partitions.end(); ++_iter296)
{
- xfer += (*_iter295).write(oprot);
+ xfer += (*_iter296).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -7428,13 +7452,13 @@ void swap(PartitionListComposingSpec &a, PartitionListComposingSpec &b) {
swap(a.__isset, b.__isset);
}
-PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other296) {
- partitions = other296.partitions;
- __isset = other296.__isset;
-}
-PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other297) {
+PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other297) {
partitions = other297.partitions;
__isset = other297.__isset;
+}
+PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other298) {
+ partitions = other298.partitions;
+ __isset = other298.__isset;
return *this;
}
void PartitionListComposingSpec::printTo(std::ostream& out) const {
@@ -7605,16 +7629,7 @@ void swap(PartitionSpec &a, PartitionSpec &b) {
swap(a.__isset, b.__isset);
}
-PartitionSpec::PartitionSpec(const PartitionSpec& other298) {
- dbName = other298.dbName;
- tableName = other298.tableName;
- rootPath = other298.rootPath;
- sharedSDPartitionSpec = other298.sharedSDPartitionSpec;
- partitionList = other298.partitionList;
- catName = other298.catName;
- __isset = other298.__isset;
-}
-PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other299) {
+PartitionSpec::PartitionSpec(const PartitionSpec& other299) {
dbName = other299.dbName;
tableName = other299.tableName;
rootPath = other299.rootPath;
@@ -7622,6 +7637,15 @@ PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other299) {
partitionList = other299.partitionList;
catName = other299.catName;
__isset = other299.__isset;
+}
+PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other300) {
+ dbName = other300.dbName;
+ tableName = other300.tableName;
+ rootPath = other300.rootPath;
+ sharedSDPartitionSpec = other300.sharedSDPartitionSpec;
+ partitionList = other300.partitionList;
+ catName = other300.catName;
+ __isset = other300.__isset;
return *this;
}
void PartitionSpec::printTo(std::ostream& out) const {
@@ -7768,19 +7792,19 @@ void swap(BooleanColumnStatsData &a, BooleanColumnStatsData &b) {
swap(a.__isset, b.__isset);
}
-BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other300) {
- numTrues = other300.numTrues;
- numFalses = other300.numFalses;
- numNulls = other300.numNulls;
- bitVectors = other300.bitVectors;
- __isset = other300.__isset;
-}
-BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other301) {
+BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other301) {
numTrues = other301.numTrues;
numFalses = other301.numFalses;
numNulls = other301.numNulls;
bitVectors = other301.bitVectors;
__isset = other301.__isset;
+}
+BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other302) {
+ numTrues = other302.numTrues;
+ numFalses = other302.numFalses;
+ numNulls = other302.numNulls;
+ bitVectors = other302.bitVectors;
+ __isset = other302.__isset;
return *this;
}
void BooleanColumnStatsData::printTo(std::ostream& out) const {
@@ -7943,21 +7967,21 @@ void swap(DoubleColumnStatsData &a, DoubleColumnStatsData &b) {
swap(a.__isset, b.__isset);
}
-DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other302) {
- lowValue = other302.lowValue;
- highValue = other302.highValue;
- numNulls = other302.numNulls;
- numDVs = other302.numDVs;
- bitVectors = other302.bitVectors;
- __isset = other302.__isset;
-}
-DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other303) {
+DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other303) {
lowValue = other303.lowValue;
highValue = other303.highValue;
numNulls = other303.numNulls;
numDVs = other303.numDVs;
bitVectors = other303.bitVectors;
__isset = other303.__isset;
+}
+DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other304) {
+ lowValue = other304.lowValue;
+ highValue = other304.highValue;
+ numNulls = other304.numNulls;
+ numDVs = other304.numDVs;
+ bitVectors = other304.bitVectors;
+ __isset = other304.__isset;
return *this;
}
void DoubleColumnStatsData::printTo(std::ostream& out) const {
@@ -8121,21 +8145,21 @@ void swap(LongColumnStatsData &a, LongColumnStatsData &b) {
swap(a.__isset, b.__isset);
}
-LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other304) {
- lowValue = other304.lowValue;
- highValue = other304.highValue;
- numNulls = other304.numNulls;
- numDVs = other304.numDVs;
- bitVectors = other304.bitVectors;
- __isset = other304.__isset;
-}
-LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other305) {
+LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other305) {
lowValue = other305.lowValue;
highValue = other305.highValue;
numNulls = other305.numNulls;
numDVs = other305.numDVs;
bitVectors = other305.bitVectors;
__isset = other305.__isset;
+}
+LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other306) {
+ lowValue = other306.lowValue;
+ highValue = other306.highValue;
+ numNulls = other306.numNulls;
+ numDVs = other306.numDVs;
+ bitVectors = other306.bitVectors;
+ __isset = other306.__isset;
return *this;
}
void LongColumnStatsData::printTo(std::ostream& out) const {
@@ -8301,21 +8325,21 @@ void swap(StringColumnStatsData &a, StringColumnStatsData &b) {
swap(a.__isset, b.__isset);
}
-StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other306) {
- maxColLen = other306.maxColLen;
- avgColLen = other306.avgColLen;
- numNulls = other306.numNulls;
- numDVs = other306.numDVs;
- bitVectors = other306.bitVectors;
- __isset = other306.__isset;
-}
-StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other307) {
+StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other307) {
maxColLen = other307.maxColLen;
avgColLen = other307.avgColLen;
numNulls = other307.numNulls;
numDVs = other307.numDVs;
bitVectors = other307.bitVectors;
__isset = other307.__isset;
+}
+StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other308) {
+ maxColLen = other308.maxColLen;
+ avgColLen = other308.avgColLen;
+ numNulls = other308.numNulls;
+ numDVs = other308.numDVs;
+ bitVectors = other308.bitVectors;
+ __isset = other308.__isset;
return *this;
}
void StringColumnStatsData::printTo(std::ostream& out) const {
@@ -8461,19 +8485,19 @@ void swap(BinaryColumnStatsData &a, BinaryColumnStatsData &b) {
swap(a.__isset, b.__isset);
}
-BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other308) {
- maxColLen = other308.maxColLen;
- avgColLen = other308.avgColLen;
- numNulls = other308.numNulls;
- bitVectors = other308.bitVectors;
- __isset = other308.__isset;
-}
-BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other309) {
+BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other309) {
maxColLen = other309.maxColLen;
avgColLen = other309.avgColLen;
numNulls = other309.numNulls;
bitVectors = other309.bitVectors;
__isset = other309.__isset;
+}
+BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other310) {
+ maxColLen = other310.maxColLen;
+ avgColLen = other310.avgColLen;
+ numNulls = other310.numNulls;
+ bitVectors = other310.bitVectors;
+ __isset = other310.__isset;
return *this;
}
void BinaryColumnStatsData::printTo(std::ostream& out) const {
@@ -8578,13 +8602,13 @@ void swap(Decimal &a, Decimal &b) {
swap(a.unscaled, b.unscaled);
}
-Decimal::Decimal(const Decimal& other310) {
- scale = other310.scale;
- unscaled = other310.unscaled;
-}
-Decimal& Decimal::operator=(const Decimal& other311) {
+Decimal::Decimal(const Decimal& other311) {
scale = other311.scale;
unscaled = other311.unscaled;
+}
+Decimal& Decimal::operator=(const Decimal& other312) {
+ scale = other312.scale;
+ unscaled = other312.unscaled;
return *this;
}
void Decimal::printTo(std::ostream& out) const {
@@ -8745,21 +8769,21 @@ void swap(DecimalColumnStatsData &a, DecimalColumnStatsData &b) {
swap(a.__isset, b.__isset);
}
-DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other312) {
- lowValue = other312.lowValue;
- highValue = other312.highValue;
- numNulls = other312.numNulls;
- numDVs = other312.numDVs;
- bitVectors = other312.bitVectors;
- __isset = other312.__isset;
-}
-DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other313) {
+DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other313) {
lowValue = other313.lowValue;
highValue = other313.highValue;
numNulls = other313.numNulls;
numDVs = other313.numDVs;
bitVectors = other313.bitVectors;
__isset = other313.__isset;
+}
+DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other314) {
+ lowValue = other314.lowValue;
+ highValue = other314.highValue;
+ numNulls = other314.numNulls;
+ numDVs = other314.numDVs;
+ bitVectors = other314.bitVectors;
+ __isset = other314.__isset;
return *this;
}
void DecimalColumnStatsData::printTo(std::ostream& out) const {
@@ -8845,11 +8869,11 @@ void swap(Date &a, Date &b) {
swap(a.daysSinceEpoch, b.daysSinceEpoch);
}
-Date::Date(const Date& other314) {
- daysSinceEpoch = other314.daysSinceEpoch;
-}
-Date& Date::operator=(const Date& other315) {
+Date::Date(const Date& other315) {
daysSinceEpoch = other315.daysSinceEpoch;
+}
+Date& Date::operator=(const Date& other316) {
+ daysSinceEpoch = other316.daysSinceEpoch;
return *this;
}
void Date::printTo(std::ostream& out) const {
@@ -9009,21 +9033,21 @@ void swap(DateColumnStatsData &a, DateColumnStatsData &b) {
swap(a.__isset, b.__isset);
}
-DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other316) {
- lowValue = other316.lowValue;
- highValue = other316.highValue;
- numNulls = other316.numNulls;
- numDVs = other316.numDVs;
- bitVectors = other316.bitVectors;
- __isset = other316.__isset;
-}
-DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other317) {
+DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other317) {
lowValue = other317.lowValue;
highValue = other317.highValue;
numNulls = other317.numNulls;
numDVs = other317.numDVs;
bitVectors = other317.bitVectors;
__isset = other317.__isset;
+}
+DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other318) {
+ lowValue = other318.lowValue;
+ highValue = other318.highValue;
+ numNulls = other318.numNulls;
+ numDVs = other318.numDVs;
+ bitVectors = other318.bitVectors;
+ __isset = other318.__isset;
return *this;
}
void DateColumnStatsData::printTo(std::ostream& out) const {
@@ -9209,17 +9233,7 @@ void swap(ColumnStatisticsData &a, ColumnStatisticsData &b) {
swap(a.__isset, b.__isset);
}
-ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other318) {
- booleanStats = other318.booleanStats;
- longStats = other318.longStats;
- doubleStats = other318.doubleStats;
- stringStats = other318.stringStats;
- binaryStats = other318.binaryStats;
- decimalStats = other318.decimalStats;
- dateStats = other318.dateStats;
- __isset = other318.__isset;
-}
-ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other319) {
+ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other319) {
booleanStats = other319.booleanStats;
longStats = other319.longStats;
doubleStats = other319.doubleStats;
@@ -9228,6 +9242,16 @@ ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData
decimalStats = other319.decimalStats;
dateStats = other319.dateStats;
__isset = other319.__isset;
+}
+ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other320) {
+ booleanStats = other320.booleanStats;
+ longStats = other320.longStats;
+ doubleStats = other320.doubleStats;
+ stringStats = other320.stringStats;
+ binaryStats = other320.binaryStats;
+ decimalStats = other320.decimalStats;
+ dateStats = other320.dateStats;
+ __isset = other320.__isset;
return *this;
}
void ColumnStatisticsData::printTo(std::ostream& out) const {
@@ -9355,15 +9379,15 @@ void swap(ColumnStatisticsObj &a, ColumnStatisticsObj &b) {
swap(a.statsData, b.statsData);
}
-ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other320) {
- colName = other320.colName;
- colType = other320.colType;
- statsData = other320.statsData;
-}
-ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other321) {
+ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other321) {
colName = other321.colName;
colType = other321.colType;
statsData = other321.statsData;
+}
+ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other322) {
+ colName = other322.colName;
+ colType = other322.colType;
+ statsData = other322.statsData;
return *this;
}
void ColumnStatisticsObj::printTo(std::ostream& out) const {
@@ -9545,16 +9569,7 @@ void swap(ColumnStatisticsDesc &a, ColumnStatisticsDesc &b) {
swap(a.__isset, b.__isset);
}
-ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other322) {
- isTblLevel = other322.isTblLevel;
- dbName = other322.dbName;
- tableName = other322.tableName;
- partName = other322.partName;
- lastAnalyzed = other322.lastAnalyzed;
- catName = other322.catName;
- __isset = other322.__isset;
-}
-ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other323) {
+ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other323) {
isTblLevel = other323.isTblLevel;
dbName = other323.dbName;
tableName = other323.tableName;
@@ -9562,6 +9577,15 @@ ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc
lastAnalyzed = other323.lastAnalyzed;
catName = other323.catName;
__isset = other323.__isset;
+}
+ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other324) {
+ isTblLevel = other324.isTblLevel;
+ dbName = other324.dbName;
+ tableName = other324.tableName;
+ partName = other324.partName;
+ lastAnalyzed = other324.lastAnalyzed;
+ catName = other324.catName;
+ __isset = other324.__isset;
return *this;
}
void ColumnStatisticsDesc::printTo(std::ostream& out) const {
@@ -9624,14 +9648,14 @@ uint32_t ColumnStatistics::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->statsObj.clear();
- uint32_t _size324;
- ::apache::thrift::protocol::TType _etype327;
- xfer += iprot->readListBegin(_etype327, _size324);
- this->statsObj.resize(_size324);
- uint32_t _i328;
- for (_i328 = 0; _i328 < _size324; ++_i328)
+ uint32_t _size325;
+ ::apache::thrift::protocol::TType _etype328;
+ xfer += iprot->readListBegin(_etype328, _size325);
+ this->statsObj.resize(_size325);
+ uint32_t _i329;
+ for (_i329 = 0; _i329 < _size325; ++_i329)
{
- xfer += this->statsObj[_i328].read(iprot);
+ xfer += this->statsObj[_i329].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -9668,10 +9692,10 @@ uint32_t ColumnStatistics::write(::apache::thrift::protocol::TProtocol* oprot) c
xfer += oprot->writeFieldBegin("statsObj", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->statsObj.size()));
- std::vector<ColumnStatisticsObj> ::const_iterator _iter329;
- for (_iter329 = this->statsObj.begin(); _iter329 != this->statsObj.end(); ++_iter329)
+ std::vector<ColumnStatisticsObj> ::const_iterator _iter330;
+ for (_iter330 = this->statsObj.begin(); _iter330 != this->statsObj.end(); ++_iter330)
{
- xfer += (*_iter329).write(oprot);
+ xfer += (*_iter330).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -9688,13 +9712,13 @@ void swap(ColumnStatistics &a, ColumnStatistics &b) {
swap(a.statsObj, b.statsObj);
}
-ColumnStatistics::ColumnStatistics(const ColumnStatistics& other330) {
- statsDesc = other330.statsDesc;
- statsObj = other330.statsObj;
-}
-ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other331) {
+ColumnStatistics::ColumnStatistics(const ColumnStatistics& other331) {
statsDesc = other331.statsDesc;
statsObj = other331.statsObj;
+}
+ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other332) {
+ statsDesc = other332.statsDesc;
+ statsObj = other332.statsObj;
return *this;
}
void ColumnStatistics::printTo(std::ostream& out) const {
@@ -9745,14 +9769,14 @@ uint32_t AggrStats::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->colStats.clear();
- uint32_t _size332;
- ::apache::thrift::protocol::TType _etype335;
- xfer += iprot->readListBegin(_etype335, _size332);
- this->colStats.resize(_size332);
- uint32_t _i336;
- for (_i336 = 0; _i336 < _size332; ++_i336)
+ uint32_t _size333;
+ ::apache::thrift::protocol::TType _etype336;
+ xfer += iprot->readListBegin(_etype336, _size333);
+ this->colStats.resize(_size333);
+ uint32_t _i337;
+ for (_i337 = 0; _i337 < _size333; ++_i337)
{
- xfer += this->colStats[_i336].read(iprot);
+ xfer += this->colStats[_i337].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -9793,10 +9817,10 @@ uint32_t AggrStats::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("colStats", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->colStats.size()));
- std::vector<ColumnStatisticsObj> ::const_iterator _iter337;
- for (_iter337 = this->colStats.begin(); _iter337 != this->colStats.end(); ++_iter337)
+ std::vector<ColumnStatisticsObj> ::const_iterator _iter338;
+ for (_iter338 = this->colStats.begin(); _iter338 != this->colStats.end(); ++_iter338)
{
- xfer += (*_iter337).write(oprot);
+ xfer += (*_iter338).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -9817,13 +9841,13 @@ void swap(AggrStats &a, AggrStats &b) {
swap(a.partsFound, b.partsFound);
}
-AggrStats::AggrStats(const AggrStats& other338) {
- colStats = other338.colStats;
- partsFound = other338.partsFound;
-}
-AggrStats& AggrStats::operator=(const AggrStats& other339) {
+AggrStats::AggrStats(const AggrStats& other339) {
colStats = other339.colStats;
partsFound = other339.partsFound;
+}
+AggrStats& AggrStats::operator=(const AggrStats& other340) {
+ colStats = other340.colStats;
+ partsFound = other340.partsFound;
return *this;
}
void AggrStats::printTo(std::ostream& out) const {
@@ -9874,14 +9898,14 @@ uint32_t SetPartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->colStats.clear();
- uint32_t _size340;
- ::apache::thrift::protocol::TType _etype343;
- xfer += iprot->readListBegin(_etype343, _size340);
- this->colStats.resize(_size340);
- uint32_t _i344;
- for (_i344 = 0; _i344 < _size340; ++_i344)
+ uint32_t _size341;
+ ::apache::thrift::protocol::TType _etype344;
+ xfer += iprot->readListBegin(_etype344, _size341);
+ this->colStats.resize(_size341);
+ uint32_t _i345;
+ for (_i345 = 0; _i345 < _size341; ++_i345)
{
- xfer += this->colStats[_i344].read(iprot);
+ xfer += this->colStats[_i345].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -9920,10 +9944,10 @@ uint32_t SetPartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol*
xfer += oprot->writeFieldBegin("colStats", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->colStats.size()));
- std::vector<ColumnStatistics> ::const_iterator _iter345;
- for (_iter345 = this->colStats.begin(); _iter345 != this->colStats.end(); ++_iter345)
+ std::vector<ColumnStatistics> ::const_iterator _iter346;
+ for (_iter346 = this->colStats.begin(); _iter346 != this->colStats.end(); ++_iter346)
{
- xfer += (*_iter345).write(oprot);
+ xfer += (*_iter346).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -9946,15 +9970,15 @@ void swap(SetPartitionsStatsRequest &a, SetPartitionsStatsRequest &b) {
swap(a.__isset, b.__isset);
}
-SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other346) {
- colStats = other346.colStats;
- needMerge = other346.needMerge;
- __isset = other346.__isset;
-}
-SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other347) {
+SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other347) {
colStats = other347.colStats;
needMerge = other347.needMerge;
__isset = other347.__isset;
+}
+SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other348) {
+ colStats = other348.colStats;
+ needMerge = other348.needMerge;
+ __isset = other348.__isset;
return *this;
}
void SetPartitionsStatsRequest::printTo(std::ostream& out) const {
@@ -10003,14 +10027,14 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->fieldSchemas.clear();
- uint32_t _size348;
- ::apache::thrift::protocol::TType _etype351;
- xfer += iprot->readListBegin(_etype351, _size348);
- this->fieldSchemas.resize(_size348);
- uint32_t _i352;
- for (_i352 = 0; _i352 < _size348; ++_i352)
+ uint32_t _size349;
+ ::apache::thrift::protocol::TType _etype352;
+ xfer += iprot->readListBegin(_etype352, _size349);
+ this->fieldSchemas.resize(_size349);
+ uint32_t _i353;
+ for (_i353 = 0; _i353 < _size349; ++_i353)
{
- xfer += this->fieldSchemas[_i352].read(iprot);
+ xfer += this->fieldSchemas[_i353].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -10023,17 +10047,17 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->properties.clear();
- uint32_t _size353;
- ::apache::thrift::protocol::TType _ktype354;
- ::apache::thrift::protocol::TType _vtype355;
- xfer += iprot->readMapBegin(_ktype354, _vtype355, _size353);
- uint32_t _i357;
- for (_i357 = 0; _i357 < _size353; ++_i357)
+ uint32_t _size354;
+ ::apache::thrift::protocol::TType _ktype355;
+ ::apache::thrift::protocol::TType _vtype356;
+ xfer += iprot->readMapBegin(_ktype355, _vtype356, _size354);
+ uint32_t _i358;
+ for (_i358 = 0; _i358 < _size354; ++_i358)
{
- std::string _key358;
- xfer += iprot->readString(_key358);
- std::string& _val359 = this->properties[_key358];
- xfer += iprot->readString(_val359);
+ std::string _key359;
+ xfer += iprot->readString(_key359);
+ std::string& _val360 = this->properties[_key359];
+ xfer += iprot->readString(_val360);
}
xfer += iprot->readMapEnd();
}
@@ -10062,10 +10086,10 @@ uint32_t Schema::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("fieldSchemas", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->fieldSchemas.size()));
- std::vector<FieldSchema> ::const_iterator _iter360;
- for (_iter360 = this->fieldSchemas.begin(); _iter360 != this->fieldSchemas.end(); ++_iter360)
+ std::vector<FieldSchema> ::const_iterator _iter361;
+ for (_iter361 = this->fieldSchemas.begin(); _iter361 != this->fieldSchemas.end(); ++_iter361)
{
- xfer += (*_iter360).write(oprot);
+ xfer += (*_iter361).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -10074,11 +10098,11 @@ uint32_t Schema::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 2);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->properties.size()));
- std::map<std::string, std::string> ::const_iterator _iter361;
- for (_iter361 = this->properties.begin(); _iter361 != this->properties.end(); ++_iter361)
+ std::map<std::string, std::string> ::const_iterator _iter362;
+ for (_iter362 = this->properties.begin(); _iter362 != this->properties.end(); ++_iter362)
{
- xfer += oprot->writeString(_iter361->first);
- xfer += oprot->writeString(_iter361->second);
+ xfer += oprot->writeString(_iter362->first);
+ xfer += oprot->writeString(_iter362->second);
}
xfer += oprot->writeMapEnd();
}
@@ -10096,15 +10120,15 @@ void swap(Schema &a, Schema &b) {
swap(a.__isset, b.__isset);
}
-Schema::Schema(const Schema& other362) {
- fieldSchemas = other362.fieldSchemas;
- properties = other362.properties;
- __isset = other362.__isset;
-}
-Schema& Schema::operator=(const Schema& other363) {
+Schema::Schema(const Schema& other363) {
fieldSchemas = other363.fieldSchemas;
properties = other363.properties;
__isset = other363.__isset;
+}
+Schema& Schema::operator=(const Schema& other364) {
+ fieldSchemas = other364.fieldSchemas;
+ properties = other364.properties;
+ __isset = other364.__isset;
return *this;
}
void Schema::printTo(std::ostream& out) const {
@@ -10149,17 +10173,17 @@ uint32_t EnvironmentContext::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->properties.clear();
- uint32_t _size364;
- ::apache::thrift::protocol::TType _ktype365;
- ::apache::thrift::protocol::TType _vtype366;
- xfer += iprot->readMapBegin(_ktype365, _vtype366, _size364);
- uint32_t _i368;
- for (_i368 = 0; _i368 < _size364; ++_i368)
+ uint32_t _size365;
+ ::apache::thrift::protocol::TType _ktype366;
+ ::apache::thrift::protocol::TType _vtype367;
+ xfer += iprot->readMapBegin(_ktype366, _vtype367, _size365);
+ uint32_t _i369;
+ for (_i369 = 0; _i369 < _size365; ++_i369)
{
- std::string _key369;
- xfer += iprot->readString(_key369);
- std::string& _val370 = this->properties[_key369];
- xfer += iprot->readString(_val370);
+ std::string _key370;
+ xfer += iprot->readString(_key370);
+ std::string& _val371 = this->properties[_key370];
+ xfer += iprot->readString(_val371);
}
xfer += iprot->readMapEnd();
}
@@ -10188,11 +10212,11 @@ uint32_t EnvironmentContext::write(::apache::thrift::protocol::TProtocol* oprot)
xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 1);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->properties.size()));
- std::map<std::string, std::string> ::const_iterator _iter371;
- for (_iter371 = this->properties.begin(); _iter371 != this->properties.end(); ++_iter371)
+ std::map<std::string, std::string> ::const_iterator _iter372;
+ for (_iter372 = this->properties.begin(); _iter372 != this->properties.end(); ++_iter372)
{
- xfer += oprot->writeString(_iter371->first);
- xfer += oprot->writeString(_iter371->second);
+ xfer += oprot->writeString(_iter372->first);
+ xfer += oprot->writeString(_iter372->second);
}
xfer += oprot->writeMapEnd();
}
@@ -10209,13 +10233,13 @@ void swap(EnvironmentContext &a, EnvironmentContext &b) {
swap(a.__isset, b.__isset);
}
-EnvironmentContext::EnvironmentContext(const EnvironmentContext& other372) {
- properties = other372.properties;
- __isset = other372.__isset;
-}
-EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other373) {
+EnvironmentContext::EnvironmentContext(const EnvironmentContext& other373) {
properties = other373.properties;
__isset = other373.__isset;
+}
+EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other374) {
+ properties = other374.properties;
+ __isset = other374.__isset;
return *this;
}
void EnvironmentContext::printTo(std::ostream& out) const {
@@ -10337,17 +10361,17 @@ void swap(PrimaryKeysRequest &a, PrimaryKeysRequest &b) {
swap(a.__isset, b.__isset);
}
-PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other374) {
- db_name = other374.db_name;
- tbl_name = other374.tbl_name;
- catName = other374.catName;
- __isset = other374.__isset;
-}
-PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other375) {
+PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other375) {
db_name = other375.db_name;
tbl_name = other375.tbl_name;
catName = other375.catName;
__isset = other375.__isset;
+}
+PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other376) {
+ db_name = other376.db_name;
+ tbl_name = other376.tbl_name;
+ catName = other376.catName;
+ __isset = other376.__isset;
return *this;
}
void PrimaryKeysRequest::printTo(std::ostream& out) const {
@@ -10394,14 +10418,14 @@ uint32_t PrimaryKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->primaryKeys.clear();
- uint32_t _size376;
- ::apache::thrift::protocol::TType _etype379;
- xfer += iprot->readListBegin(_etype379, _size376);
- this->primaryKeys.resize(_size376);
- uint32_t _i380;
- for (_i380 = 0; _i380 < _size376; ++_i380)
+ uint32_t _size377;
+ ::apache::thrift::protocol::TType _etype380;
+ xfer += iprot->readListBegin(_etype380, _size377);
+ this->primaryKeys.resize(_size377);
+ uint32_t _i381;
+ for (_i381 = 0; _i381 < _size377; ++_i381)
{
- xfer += this->primaryKeys[_i380].read(iprot);
+ xfer += this->primaryKeys[_i381].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -10432,10 +10456,10 @@ uint32_t PrimaryKeysResponse::write(::apache::thrift::protocol::TProtocol* oprot
xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->primaryKeys.size()));
- std::vector<SQLPrimaryKey> ::const_iterator _iter381;
- for (_iter381 = this->primaryKeys.begin(); _iter381 != this->primaryKeys.end(); ++_iter381)
+ std::vector<SQLPrimaryKey> ::const_iterator _iter382;
+ for (_iter382 = this->primaryKeys.begin(); _iter382 != this->primaryKeys.end(); ++_iter382)
{
- xfer += (*_iter381).write(oprot);
+ xfer += (*_iter382).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -10451,11 +10475,11 @@ void swap(PrimaryKeysResponse &a, PrimaryKeysResponse &b) {
swap(a.primaryKeys, b.primaryKeys);
}
-PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other382) {
- primaryKeys = other382.primaryKeys;
-}
-PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other383) {
+PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other383) {
primaryKeys = other383.primaryKeys;
+}
+PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other384) {
+ primaryKeys = other384.primaryKeys;
return *this;
}
void PrimaryKeysResponse::printTo(std::ostream& out) const {
@@ -10605,21 +10629,21 @@ void swap(ForeignKeysRequest &a, ForeignKeysRequest &b) {
swap(a.__isset, b.__isset);
}
-ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other384) {
- parent_db_name = other384.parent_db_name;
- parent_tbl_name = other384.parent_tbl_name;
- foreign_db_name = other384.foreign_db_name;
- foreign_tbl_name = other384.foreign_tbl_name;
- catName = other384.catName;
- __isset = other384.__isset;
-}
-ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other385) {
+ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other385) {
parent_db_name = other385.parent_db_name;
parent_tbl_name = other385.parent_tbl_name;
foreign_db_name = other385.foreign_db_name;
foreign_tbl_name = other385.foreign_tbl_name;
catName = other385.catName;
__isset = other385.__isset;
+}
+ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other386) {
+ parent_db_name = other386.parent_db_name;
+ parent_tbl_name = other386.parent_tbl_name;
+ foreign_db_name = other386.foreign_db_name;
+ foreign_tbl_name = other386.foreign_tbl_name;
+ catName = other386.catName;
+ __isset = other386.__isset;
return *this;
}
void ForeignKeysRequest::printTo(std::ostream& out) const {
@@ -10668,14 +10692,14 @@ uint32_t ForeignKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->foreignKeys.clear();
- uint32_t _size386;
- ::apache::thrift::protocol::TType _etype389;
- xfer += iprot->readListBegin(_etype389, _size386);
- this->foreignKeys.resize(_size386);
- uint32_t _i390;
- for (_i390 = 0; _i390 < _size386; ++_i390)
+ uint32_t _size387;
+ ::apache::thrift::protocol::TType _etype390;
+ xfer += iprot->readListBegin(_etype390, _size387);
+ this->foreignKeys.resize(_size387);
+ uint32_t _i391;
+ for (_i391 = 0; _i391 < _size387; ++_i391)
{
- xfer += this->foreignKeys[_i390].read(iprot);
+ xfer += this->foreignKeys[_i391].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -10706,10 +10730,10 @@ uint32_t ForeignKeysResponse::write(::apache::thrift::protocol::TProtocol* oprot
xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->foreignKeys.size()));
- std::vector<SQLForeignKey> ::const_iterator _iter391;
- for (_iter391 = this->foreignKeys.begin(); _iter391 != this->foreignKeys.end(); ++_iter391)
+ std::vector<SQLForeignKey> ::const_iterator _iter392;
+ for (_iter392 = this->foreignKeys.begin(); _iter392 != this->foreignKeys.end(); ++_iter392)
{
- xfer += (*_iter391).write(oprot);
+ xfer += (*_iter392).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -10725,11 +10749,11 @@ void swap(ForeignKeysResponse &a, ForeignKeysResponse &b) {
swap(a.foreignKeys, b.foreignKeys);
}
-ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other392) {
- foreignKeys = other392.foreignKeys;
-}
-ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other393) {
+ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other393) {
foreignKeys = other393.foreignKeys;
+}
+ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other394) {
+ foreignKeys = other394.foreignKeys;
return *this;
}
void ForeignKeysResponse::printTo(std::ostream& out) const {
@@ -10851,15 +10875,15 @@ void swap(UniqueConstraintsRequest &a, UniqueConstraintsRequest &b) {
swap(a.tbl_name, b.tbl_name);
}
-UniqueConstraintsRequest::UniqueConstraintsRequest(const UniqueConstraintsRequest& other394) {
- catName = other394.catName;
- db_name = other394.db_name;
- tbl_name = other394.tbl_name;
-}
-UniqueConstraintsRequest& UniqueConstraintsRequest::operator=(const UniqueConstraintsRequest& other395) {
+UniqueConstraintsRequest::UniqueConstraintsRequest(const UniqueConstraintsRequest& other395) {
catName = other395.catName;
db_name = other395.db_name;
tbl_name = other395.tbl_name;
+}
+UniqueConstraintsRequest& UniqueConstraintsRequest::operator=(const UniqueConstraintsRequest& other396) {
+ catName = other396.catName;
+ db_name = other396.db_name;
+ tbl_name = other396.tbl_name;
return *this;
}
void UniqueConstraintsRequest::printTo(std::ostream& out) const {
@@ -10906,14 +10930,14 @@ uint32_t UniqueConstraintsResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->uniqueConstraints.clear();
- uint32_t _size396;
- ::apache::thrift::protocol::TType _etype399;
- xfer += iprot->readListBegin(_etype399, _size396);
- this->uniqueConstraints.resize(_size396);
- uint32_t _i400;
- for (_i400 = 0; _i400 < _size396; ++_i400)
+ uint32_t _size397;
+ ::apache::thrift::protocol::TType _etype400;
+ xfer += iprot->readListBegin(_etype400, _size397);
+ this->uniqueConstraints.resize(_size397);
+ uint32_t _i401;
+ for (_i401 = 0; _i401 < _size397; ++_i401)
{
- xfer += this->uniqueConstraints[_i400].read(iprot);
+ xfer += this->uniqueConstraints[_i401].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -10944,10 +10968,10 @@ uint32_t UniqueConstraintsResponse::write(::apache::thrift::protocol::TProtocol*
xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->uniqueConstraints.size()));
- std::vector<SQLUniqueConstraint> ::const_iterator _iter401;
- for (_iter401 = this->uniqueConstraints.begin(); _iter401 != this->uniqueConstraints.end(); ++_iter401)
+ std::vector<SQLUniqueConstraint> ::const_iterator _iter402;
+ for (_iter402 = this->uniqueConstraints.begin(); _iter402 != this->uniqueConstraints.end(); ++_iter402)
{
- xfer += (*_iter401).write(oprot);
+ xfer += (*_iter402).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -10963,11 +10987,11 @@ void swap(UniqueConstraintsResponse &a, UniqueConstraintsResponse &b) {
swap(a.uniqueConstraints, b.uniqueConstraints);
}
-UniqueConstraintsResponse::UniqueConstraintsResponse(const UniqueConstraintsResponse& other402) {
- uniqueConstraints = other402.uniqueConstraints;
-}
-UniqueConstraintsResponse& UniqueConstraintsResponse::operator=(const UniqueConstraintsResponse& other403) {
+UniqueConstraintsResponse::UniqueConstraintsResponse(const UniqueConstraintsResponse& other403) {
uniqueConstraints = other403.uniqueConstraints;
+}
+UniqueConstraintsResponse& UniqueConstraintsResponse::operator=(const UniqueConstraintsResponse& other404) {
+ uniqueConstraints = other404.uniqueConstraints;
return *this;
}
void UniqueConstraintsResponse::printTo(std::ostream& out) const {
@@ -11089,15 +11113,15 @@ void swap(NotNullConstraintsRequest &a, NotNullConstraintsRequest &b) {
swap(a.tbl_name, b.tbl_name);
}
-NotNullConstraintsRequest::NotNullConstraintsRequest(const NotNullConstraintsRequest& other404) {
- catName = other404.catName;
- db_name = other404.db_name;
- tbl_name = other404.tbl_name;
-}
-NotNullConstraintsRequest& NotNullConstraintsRequest::operator=(const NotNullConstraintsRequest& other405) {
+NotNullConstraintsRequest::NotNullConstraintsRequest(const NotNullConstraintsRequest& other405) {
catName = other405.catName;
db_name = other405.db_name;
tbl_name = other405.tbl_name;
+}
+NotNullConstraintsRequest& NotNullConstraintsRequest::operator=(const NotNullConstraintsRequest& other406) {
+ catName = other406.catName;
+ db_name = other406.db_name;
+ tbl_name = other406.tbl_name;
return *this;
}
void NotNullConstraintsRequest::printTo(std::ostream& out) const {
@@ -11144,14 +11168,14 @@ uint32_t NotNullConstraintsResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->notNullConstraints.clear();
- uint32_t _size406;
- ::apache::thrift::protocol::TType _etype409;
- xfer += iprot->readListBegin(_etype409, _size406);
- this->notNullConstraints.resize(_size406);
- uint32_t _i410;
- for (_i410 = 0; _i410 < _size406; ++_i410)
+ uint32_t _size407;
+ ::apache::thrift::protocol::TType _etype410;
+ xfer += iprot->readListBegin(_etype410, _size407);
+ this->notNullConstraints.resize(_size407);
+ uint32_t _i411;
+ for (_i411 = 0; _i411 < _size407; ++_i411)
{
- xfer += this->notNullConstraints[_i410].read(iprot);
+ xfer += this->notNullConstraints[_i411].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -11182,10 +11206,10 @@ uint32_t NotNullConstraintsResponse::write(::apache::thrift::protocol::TProtocol
xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->notNullConstraints.size()));
- std::vector<SQLNotNullConstraint> ::const_iterator _iter411;
- for (_iter411 = this->notNullConstraints.begin(); _iter411 != this->notNullConstraints.end(); ++_iter411)
+ std::vector<SQLNotNullConstraint> ::const_iterator _iter412;
+ for (_iter412 = this->notNullConstraints.begin(); _iter412 != this->notNullConstraints.end(); ++_iter412)
{
- xfer += (*_iter411).write(oprot);
+ xfer += (*_iter412).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11201,11 +11225,11 @@ void swap(NotNullConstraintsResponse &a, NotNullConstraintsResponse &b) {
swap(a.notNullConstraints, b.notNullConstraints);
}
-NotNullConstraintsResponse::NotNullConstraintsResponse(const NotNullConstraintsResponse& other412) {
- notNullConstraints = other412.notNullConstraints;
-}
-NotNullConstraintsResponse& NotNullConstraintsResponse::operator=(const NotNullConstraintsResponse& other413) {
+NotNullConstraintsResponse::NotNullConstraintsResponse(const NotNullConstraintsResponse& other413) {
notNullConstraints = other413.notNullConstraints;
+}
+NotNullConstraintsResponse& NotNullConstraintsResponse::operator=(const NotNullConstraintsResponse& other414) {
+ notNullConstraints = other414.notNullConstraints;
return *this;
}
void NotNullConstraintsResponse::printTo(std::ostream& out) const {
@@ -11327,15 +11351,15 @@ void swap(DefaultConstraintsRequest &a, DefaultConstraintsRequest &b) {
swap(a.tbl_name, b.tbl_name);
}
-DefaultConstraintsRequest::DefaultConstraintsRequest(const DefaultConstraintsRequest& other414) {
- catName = other414.catName;
- db_name = other414.db_name;
- tbl_name = other414.tbl_name;
-}
-DefaultConstraintsRequest& DefaultConstraintsRequest::operator=(const DefaultConstraintsRequest& other415) {
+DefaultConstraintsRequest::DefaultConstraintsRequest(const DefaultConstraintsRequest& other415) {
catName = other415.catName;
db_name = other415.db_name;
tbl_name = other415.tbl_name;
+}
+DefaultConstraintsRequest& DefaultConstraintsRequest::operator=(const DefaultConstraintsRequest& other416) {
+ catName = other416.catName;
+ db_name = other416.db_name;
+ tbl_name = other416.tbl_name;
return *this;
}
void DefaultConstraintsRequest::printTo(std::ostream& out) const {
@@ -11382,14 +11406,14 @@ uint32_t DefaultConstraintsResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->defaultConstraints.clear();
- uint32_t _size416;
- ::apache::thrift::protocol::TType _etype419;
- xfer += iprot->readListBegin(_etype419, _size416);
- this->defaultConstraints.resize(_size416);
- uint32_t _i420;
- for (_i420 = 0; _i420 < _size416; ++_i420)
+ uint32_t _size417;
+ ::apache::thrift::protocol::TType _etype420;
+ xfer += iprot->readListBegin(_etype420, _size417);
+ this->defaultConstraints.resize(_size417);
+ uint32_t _i421;
+ for (_i421 = 0; _i421 < _size417; ++_i421)
{
- xfer += this->defaultConstraints[_i420].read(iprot);
+ xfer += this->defaultConstraints[_i421].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -11420,10 +11444,10 @@ uint32_t DefaultConstraintsResponse::write(::apache::thrift::protocol::TProtocol
xfer += oprot->writeFieldBegin("defaultConstraints", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->defaultConstraints.size()));
- std::vector<SQLDefaultConstraint> ::const_iterator _iter421;
- for (_iter421 = this->defaultConstraints.begin(); _iter421 != this->defaultConstraints.end(); ++_iter421)
+ std::vector<SQLDefaultConstraint> ::const_iterator _iter422;
+ for (_iter422 = this->defaultConstraints.begin(); _iter422 != this->defaultConstraints.end(); ++_iter422)
{
- xfer += (*_iter421).write(oprot);
+ xfer += (*_iter422).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11439,11 +11463,11 @@ void swap(DefaultConstraintsResponse &a, DefaultConstraintsResponse &b) {
swap(a.defaultConstraints, b.defaultConstraints);
}
-DefaultConstraintsResponse::DefaultConstraintsResponse(const DefaultConstraintsResponse& other422) {
- defaultConstraints = other422.defaultConstraints;
-}
-DefaultConstraintsResponse& DefaultConstraintsResponse::operator=(const DefaultConstraintsResponse& other423) {
+DefaultConstraintsResponse::DefaultConstraintsResponse(const DefaultConstraintsResponse& other423) {
defaultConstraints = other423.defaultConstraints;
+}
+DefaultConstraintsResponse& DefaultConstraintsResponse::operator=(const DefaultConstraintsResponse& other424) {
+ defaultConstraints = other424.defaultConstraints;
return *this;
}
void DefaultConstraintsResponse::printTo(std::ostream& out) const {
@@ -11565,15 +11589,15 @@ void swap(CheckConstraintsRequest &a, CheckConstraintsRequest &b) {
swap(a.tbl_name, b.tbl_name);
}
-CheckConstraintsRequest::CheckConstraintsRequest(const CheckConstraintsRequest& other424) {
- catName = other424.catName;
- db_name = other424.db_name;
- tbl_name = other424.tbl_name;
-}
-CheckConstraintsRequest& CheckConstraintsRequest::operator=(const CheckConstraintsRequest& other425) {
+CheckConstraintsRequest::CheckConstraintsRequest(const CheckConstraintsRequest& other425) {
catName = other425.catName;
db_name = other425.db_name;
tbl_name = other425.tbl_name;
+}
+CheckConstraintsRequest& CheckConstraintsRequest::operator=(const CheckConstraintsRequest& other426) {
+ catName = other426.catName;
+ db_name = other426.db_name;
+ tbl_name = other426.tbl_name;
return *this;
}
void CheckConstraintsRequest::printTo(std::ostream& out) const {
@@ -11620,14 +11644,14 @@ uint32_t CheckConstraintsResponse::read(::apache::thrift::protocol::TProtocol* i
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->checkConstraints.clear();
- uint32_t _size426;
- ::apache::thrift::protocol::TType _etype429;
- xfer += iprot->readListBegin(_etype429, _size426);
- this->checkConstraints.resize(_size426);
- uint32_t _i430;
- for (_i430 = 0; _i430 < _size426; ++_i430)
+ uint32_t _size427;
+ ::apache::thrift::protocol::TType _etype430;
+ xfer += iprot->readListBegin(_etype430, _size427);
+ this->checkConstraints.resize(_size427);
+ uint32_t _i431;
+ for (_i431 = 0; _i431 < _size427; ++_i431)
{
- xfer += this->checkConstraints[_i430].read(iprot);
+ xfer += this->checkConstraints[_i431].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -11658,10 +11682,10 @@ uint32_t CheckConstraintsResponse::write(::apache::thrift::protocol::TProtocol*
xfer += oprot->writeFieldBegin("checkConstraints", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->checkConstraints.size()));
- std::vector<SQLCheckConstraint> ::const_iterator _iter431;
- for (_iter431 = this->checkConstraints.begin(); _iter431 != this->checkConstraints.end(); ++_iter431)
+ std::vector<SQLCheckConstraint> ::const_iterator _iter432;
+ for (_iter432 = this->checkConstraints.begin(); _iter432 != this->checkConstraints.end(); ++_iter432)
{
- xfer += (*_iter431).write(oprot);
+ xfer += (*_iter432).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11677,11 +11701,11 @@ void swap(CheckConstraintsResponse &a, CheckConstraintsResponse &b) {
swap(a.checkConstraints, b.checkConstraints);
}
-CheckConstraintsResponse::CheckConstraintsResponse(const CheckConstraintsResponse& other432) {
- checkConstraints = other432.checkConstraints;
-}
-CheckConstraintsResponse& CheckConstraintsResponse::operator=(const CheckConstraintsResponse& other433) {
+CheckConstraintsResponse::CheckConstraintsResponse(const CheckConstraintsResponse& other433) {
checkConstraints = other433.checkConstraints;
+}
+CheckConstraintsResponse& CheckConstraintsResponse::operator=(const CheckConstraintsResponse& other434) {
+ checkConstraints = other434.checkConstraints;
return *this;
}
void CheckConstraintsResponse::printTo(std::ostream& out) const {
@@ -11823,19 +11847,19 @@ void swap(DropConstraintRequest &a, DropConstraintRequest &b) {
swap(a.__isset, b.__isset);
}
-DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other434) {
- dbname = other434.dbname;
- tablename = other434.tablename;
- constraintname = other434.constraintname;
- catName = other434.catName;
- __isset = other434.__isset;
-}
-DropConstraintRequest& DropConstraintRequest::operator=(const DropConstraintRequest& other435) {
+DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other435) {
dbname = other435.dbname;
tablename = other435.tablename;
constraintname = other435.constraintname;
catName = other435.catName;
__isset = other435.__isset;
+}
+DropConstraintRequest& DropConstraintRequest::operator=(const DropConstraintRequest& other436) {
+ dbname = other436.dbname;
+ tablename = other436.tablename;
+ constraintname = other436.constraintname;
+ catName = other436.catName;
+ __isset = other436.__isset;
return *this;
}
void DropConstraintRequest::printTo(std::ostream& out) const {
@@ -11883,14 +11907,14 @@ uint32_t AddPrimaryKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->primaryKeyCols.clear();
- uint32_t _size436;
- ::apache::thrift::protocol::TType _etype439;
- xfer += iprot->readListBegin(_etype439, _size436);
- this->primaryKeyCols.resize(_size436);
- uint32_t _i440;
- for (_i440 = 0; _i440 < _size436; ++_i440)
+ uint32_t _size437;
+ ::apache::thrift::protocol::TType _etype440;
+ xfer += iprot->readListBegin(_etype440, _size437);
+ this->primaryKeyCols.resize(_size437);
+ uint32_t _i441;
+ for (_i441 = 0; _i441 < _size437; ++_i441)
{
- xfer += this->primaryKeyCols[_i440].read(iprot);
+ xfer += this->primaryKeyCols[_i441].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -11921,10 +11945,10 @@ uint32_t AddPrimaryKeyRequest::write(::apache::thrift::protocol::TProtocol* opro
xfer += oprot->writeFieldBegin("primaryKeyCols", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->primaryKeyCols.size()));
- std::vector<SQLPrimaryKey> ::const_iterator _iter441;
- for (_iter441 = this->primaryKeyCols.begin(); _iter441 != this->primaryKeyCols.end(); ++_iter441)
+ std::vector<SQLPrimaryKey> ::const_iterator _iter442;
+ for (_iter442 = this->primaryKeyCols.begin(); _iter442 != this->primaryKeyCols.end(); ++_iter442)
{
- xfer += (*_iter441).write(oprot);
+ xfer += (*_iter442).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11940,11 +11964,11 @@ void swap(AddPrimaryKeyRequest &a, AddPrimaryKeyRequest &b) {
swap(a.primaryKeyCols, b.primaryKeyCols);
}
-AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& other442) {
- primaryKeyCols = other442.primaryKeyCols;
-}
-AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const AddPrimaryKeyRequest& other443) {
+AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& other443) {
primaryKeyCols = other443.primaryKeyCols;
+}
+AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const AddPrimaryKeyRequest& other444) {
+ primaryKeyCols = other444.primaryKeyCols;
return *this;
}
void AddPrimaryKeyRequest::printTo(std::ostream& out) const {
@@ -11989,14 +12013,14 @@ uint32_t AddForeignKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->foreignKeyCols.clear();
- uint32_t _size444;
- ::apache::thrift::protocol::TType _etype447;
- xfer += iprot->readListBegin(_etype447, _size444);
- this->foreignKeyCols.resize(_size444);
- uint32_t _i448;
- for (_i448 = 0; _i448 < _size444; ++_i448)
+ uint32_t _size445;
+ ::apache::thrift::protocol::TType _etype448;
+ xfer += iprot->readListBegin(_etype448, _size445);
+ this->foreignKeyCols.resize(_size445);
+ uint32_t _i449;
+ for (_i449 = 0; _i449 < _size445; ++_i449)
{
- xfer += this->foreignKeyCols[_i448].read(iprot);
+ xfer += this->foreignKeyCols[_i449].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -12027,10 +12051,10 @@ uint32_t AddForeignKeyRequest::write(::apache::thrift::protocol::TProtocol* opro
xfer += oprot->writeFieldBegin("foreignKeyCols", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->foreignKeyCols.size()));
- std::vector<SQLForeignKey> ::const_iterator _iter449;
- for (_iter449 = this->foreignKeyCols.begin(); _iter449 != this->foreignKeyCols.end(); ++_iter449)
+ std::vector<SQLForeignKey> ::const_iterator _iter450;
+ for (_iter450 = this->foreignKeyCols.begin(); _iter450 != this->foreignKeyCols.end(); ++_iter450)
{
- xfer += (*_iter449).write(oprot);
+ xfer += (*_iter450).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -12046,11 +12070,11 @@ void swap(AddForeignKeyRequest &a, AddForeignKeyRequest &b) {
swap(a.foreignKeyCols, b.foreignKeyCols);
}
-AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& other450) {
- foreignKeyCols = other450.foreignKeyCols;
-}
-AddForeignKeyRequest& AddForeignKeyRequest::operator=(const AddForeignKeyRequest& other451) {
+AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& other451) {
foreignKeyCols = other451.foreignKeyCols;
+}
+AddForeignKeyRequest& AddForeignKeyRequest::operator=(const AddForeignKeyRequest& other452) {
+ foreignKeyCols = other452.foreignKeyCols;
return *this;
}
void AddForeignKeyRequest::printTo(std::ostream& out) const {
@@ -12095,14 +12119,14 @@ uint32_t AddUniqueConstraintRequest::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->uniqueConstraintCols.clear();
- uint32_t _size452;
- ::apache::thrift::protocol::TType _etype455;
- xfer += iprot->readListBegin(_etype455, _size452);
- this->uniqueConstraintCols.resize(_size452);
- uint32_t _i456;
- for (_i456 = 0; _i456 < _size452; ++_i456)
+ uint32_t _size453;
+ ::apache::thrift::protocol::TType _etype456;
+ xfer += iprot->readListBegin(_etype456, _size453);
+ this->uniqueConstraintCols.resize(_size453);
+ uint32_t _i457;
+ for (_i457 = 0; _i457 < _size453; ++_i457)
{
- xfer += this->uniqueConstraintCols[_i456].read(iprot);
+ xfer += this->uniqueConstraintCols[_i457].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -12133,10 +12157,10 @@ uint32_t AddUniqueConstraintRequest::write(::apache::thrift::protocol::TProtocol
xfer += oprot->writeFieldBegin("uniqueConstraintCols", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->uniqueConstraintCols.size()));
- std::vector<SQLUniqueConstraint> ::const_iterator _iter457;
- for (_iter457 = this->uniqueConstraintCols.begin(); _iter457 != this->uniqueConstraintCols.end(); ++_iter457)
+ std::vector<SQLUniqueConstraint> ::const_iterator _iter458;
+ for (_iter458 = this->uniqueConstraintCols.begin(); _iter458 != this->uniqueConstraintCols.end(); ++_iter458)
{
- xfer += (*_iter457).write(oprot);
+ xfer += (*_iter458).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -12152,11 +12176,11 @@ void swap(AddUniqueConstraintRequest &a, AddUniqueConstraintRequest &b) {
swap(a.uniqueConstraintCols, b.uniqueConstraintCols);
}
-AddUniqueConstraintRequest::AddUniqueConstraintRequest(const AddUniqueConstraintRequest& other458) {
- uniqueConstraintCols = other458.uniqueConstraintCols;
-}
-AddUniqueConstraintRequest& AddUniqueConstraintRequest::operator=(const AddUniqueConstraintRequest& other459) {
+AddUniqueConstraintRequest::AddUniqueConstraintRequest(const AddUniqueConstraintRequest& other459) {
uniqueConstraintCols = other459.uniqueConstraintCols;
+}
+AddUniqueConstraintRequest& AddUniqueConstraintRequest::operator=(const AddUniqueConstraintRequest& other460) {
+ uniqueConstraintCols = other460.uniqueConstraintCols;
return *this;
}
void AddUniqueConstraintRequest::printTo(std::ostream& out) const {
@@ -12201,14 +12225,14 @@ uint32_t AddNotNullConstraintRequest::read(::apache::thrift::protocol::TProtocol
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->notNullConstraintCols.clear();
- uint32_t _size460;
- ::apache::thrift::protocol::TType _etype463;
- xfer += iprot->readListBegin(_etype463, _size460);
- this->notNullConstraintCols.resize(_size460);
- uint32_t _i464;
- for (_i464 = 0; _i464 < _size460; ++_i464)
+ uint32_t _size461;
+ ::apache::thrift::protocol::TType _etype464;
+ xfer += iprot->readListBegin(_etype464, _size461);
+ this->notNullConstraintCols.resize(_size461);
+ uint32_t _i465;
+ for (_i465 = 0; _i465 < _size461; ++_i465)
{
- xfer += this->notNullConstraintCols[_i464].read(iprot);
+ xfer += this->notNullConstraintCols[_i465].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -12239,10 +12263,10 @@ uint32_t AddNotNullConstraintRequest::write(::apache::thrift::protocol::TProtoco
xfer += oprot->writeFieldBegin("notNullConstraintCols", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->notNullConstraintCols.size()));
- std::vector<SQLNotNullConstraint> ::const_iterator _iter465;
- for (_iter465 = this->notNullConstraintCols.begin(); _iter465 != this->notNullConstraintCols.end(); ++_iter465)
+ std::vector<SQLNotNullConstraint> ::const_iterator _iter466;
+ for (_iter466 = this->notNullConstraintCols.begin(); _iter466 != this->notNullConstraintCols.end(); ++_iter466)
{
- xfer += (*_iter465).write(oprot);
+ xfer += (*_iter466).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -12258,11 +12282,11 @@ void swap(AddNotNullConstraintRequest &a, AddNotNullConstraintRequest &b) {
swap(a.notNullConstraintCols, b.notNullConstraintCols);
}
-AddNotNullConstraintRequest::AddNotNullConstraintRequest(const AddNotNullConstraintRequest& other466) {
- notNullConstraintCols = other466.notNullConstraintCols;
-}
-AddNotNullConstraintRequest& AddNotNullConstraintRequest::operator=(const AddNotNullConstraintRequest& other467) {
+AddNotNullConstraintRequest::AddNotNullConstraintRequest(const AddNotNullConstraintRequest& other467) {
notNullConstraintCols = other467.notNullConstraintCols;
+}
+AddNotNullConstraintRequest& AddNotNullConstraintRequest::operator=(const AddNotNullConstraintRequest& other468) {
+ notNullConstraintCols = other468.notNullConstraintCols;
return *this;
}
void AddNotNullConstraintRequest::printTo(std::ostream& out) const {
@@ -12307,14 +12331,14 @@ uint32_t AddDefaultConstraintRequest::read(::apache::thrift::protocol::TProtocol
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->defaultConstraintCols.clear();
- uint32_t _size468;
- ::apache::thrift::protocol::TType _etype471;
- xfer += iprot->readListBegin(_etype471, _size468);
- this->defaultConstraintCols.resize(_size468);
- uint32_t _i472;
- for (_i472 = 0; _i472 < _size468; ++_i472)
+ uint32_t _size469;
+ ::apache::thrift::protocol::TType _etype472;
+ xfer += iprot->readListBegin(_etype472, _size469);
+ this->defaultConstraintCols.resize(_size469);
+ uint32_t _i473;
+ for (_i473 = 0; _i473 < _size469; ++_i473)
{
- xfer += this->defaultConstraintCols[_i472].read(iprot);
+ xfer += this->defaultConstraintCols[_i473].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -12345,10 +12369,10 @@ uint32_t AddDefaultConstraintRequest::write(::apache::thrift::protocol::TProtoco
xfer += oprot->writeFieldBegin("defaultConstraintCols", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->defaultConstraintCols.size()));
- std::vector<SQLDefaultConstraint> ::const_iterator _iter473;
- for (_iter473 = this->defaultConstraintCols.begin(); _iter473 != this->defaultConstraintCols.end(); ++_iter473)
+ std::vector<SQLDefaultConstraint> ::const_iterator _iter474;
+ for (_iter474 = this->defaultConstraintCols.begin(); _iter474 != this->defaultConstraintCols.end(); ++_iter474)
{
- xfer += (*_iter473).write(oprot);
+ xfer += (*_iter474).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -12364,11 +12388,11 @@ void swap(AddDefaultConstraintRequest &a, AddDefaultConstraintRequest &b) {
swap(a.defaultConstraintCols, b.defaultConstraintCols);
}
-AddDefaultConstraintRequest::AddDefaultConstraintRequest(const AddDefaultConstraintRequest& other474) {
- defaultConstraintCols = other474.defaultConstraintCols;
-}
-AddDefaultConstraintRequest& AddDefaultConstraintRequest::operator=(const AddDefaultConstraintRequest& other475) {
+AddDefaultConstraintRequest::AddDefaultConstraintRequest(const AddDefaultConstraintRequest& other475) {
defaultConstraintCols = other475.defaultConstraintCols;
+}
+AddDefaultConstraintRequest& AddDefaultConstraintRequest::operator=(const AddDefaultConstraintRequest& other476) {
+ defaultConstraintCols = other476.defaultConstraintCols;
return *this;
}
void AddDefaultConstraintRequest::printTo(std::ostream& out) const {
@@ -12413,14 +12437,14 @@ uint32_t AddCheckConstraintRequest::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->checkConstraintCols.clear();
- uint32_t _size476;
- ::apache::thrift::protocol::TType _etype479;
- xfer += iprot->readListBegin(_etype479, _size476);
- this->checkConstraintCols.resize(_size476);
- uint32_t _i480;
- for (_i480 = 0; _i480 < _size476; ++_i480)
+ uint32_t _size477;
+ ::apache::thrift::protocol::TType _etype480;
+ xfer += iprot->readListBegin(_etype480, _size477);
+ this->checkConstraintCols.resize(_size477);
+ uint32_t _i481;
+ for (_i481 = 0; _i481 < _size477; ++_i481)
{
- xfer += this->checkConstraintCols[_i480].read(iprot);
+ xfer += this->checkConstraintCols[_i481].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -12451,10 +12475,10 @@ uint32_t AddCheckConstraintRequest::write(::apache::thrift::protocol::TProtocol*
xfer += oprot->writeFieldBegin("checkConstraintCols", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->checkConstraintCols.size()));
- std::vector<SQLCheckConstraint> ::const_iterator _iter481;
- for (_iter481 = this->checkConstraintCols.begin(); _iter481 != this->checkConstraintCols.end(); ++_iter481)
+ std::vector<SQLCheckConstraint> ::const_iterator _iter482;
+ for (_iter482 = this->checkConstraintCols.begin(); _iter482 != this->checkConstraintCols.end(
<TRUNCATED>