hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From w...@apache.org
Subject [12/31] hive git commit: HIVE-16575: Support for 'UNIQUE' and 'NOT NULL' constraints (Jesus Camacho Rodriguez, reviewed by Ashutosh Chauhan)
Date Thu, 25 May 2017 20:49:51 GMT
http://git-wip-us.apache.org/repos/asf/hive/blob/696be9f5/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py b/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py
index f26cb5b..1e2b890 100644
--- a/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py
+++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py
@@ -821,28 +821,40 @@ class SQLForeignKey:
   def __ne__(self, other):
     return not (self == other)
 
-class Type:
+class SQLUniqueConstraint:
   """
   Attributes:
-   - name
-   - type1
-   - type2
-   - fields
+   - table_db
+   - table_name
+   - column_name
+   - key_seq
+   - uk_name
+   - enable_cstr
+   - validate_cstr
+   - rely_cstr
   """
 
   thrift_spec = (
     None, # 0
-    (1, TType.STRING, 'name', None, None, ), # 1
-    (2, TType.STRING, 'type1', None, None, ), # 2
-    (3, TType.STRING, 'type2', None, None, ), # 3
-    (4, TType.LIST, 'fields', (TType.STRUCT,(FieldSchema, FieldSchema.thrift_spec)), None, ), # 4
+    (1, TType.STRING, 'table_db', None, None, ), # 1
+    (2, TType.STRING, 'table_name', None, None, ), # 2
+    (3, TType.STRING, 'column_name', None, None, ), # 3
+    (4, TType.I32, 'key_seq', None, None, ), # 4
+    (5, TType.STRING, 'uk_name', None, None, ), # 5
+    (6, TType.BOOL, 'enable_cstr', None, None, ), # 6
+    (7, TType.BOOL, 'validate_cstr', None, None, ), # 7
+    (8, TType.BOOL, 'rely_cstr', None, None, ), # 8
   )
 
-  def __init__(self, name=None, type1=None, type2=None, fields=None,):
-    self.name = name
-    self.type1 = type1
-    self.type2 = type2
-    self.fields = fields
+  def __init__(self, table_db=None, table_name=None, column_name=None, key_seq=None, uk_name=None, enable_cstr=None, validate_cstr=None, rely_cstr=None,):
+    self.table_db = table_db
+    self.table_name = table_name
+    self.column_name = column_name
+    self.key_seq = key_seq
+    self.uk_name = uk_name
+    self.enable_cstr = enable_cstr
+    self.validate_cstr = validate_cstr
+    self.rely_cstr = rely_cstr
 
   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:
@@ -855,28 +867,42 @@ class Type:
         break
       if fid == 1:
         if ftype == TType.STRING:
-          self.name = iprot.readString()
+          self.table_db = iprot.readString()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.STRING:
-          self.type1 = iprot.readString()
+          self.table_name = iprot.readString()
         else:
           iprot.skip(ftype)
       elif fid == 3:
         if ftype == TType.STRING:
-          self.type2 = iprot.readString()
+          self.column_name = iprot.readString()
         else:
           iprot.skip(ftype)
       elif fid == 4:
-        if ftype == TType.LIST:
-          self.fields = []
-          (_etype3, _size0) = iprot.readListBegin()
-          for _i4 in xrange(_size0):
-            _elem5 = FieldSchema()
-            _elem5.read(iprot)
-            self.fields.append(_elem5)
-          iprot.readListEnd()
+        if ftype == TType.I32:
+          self.key_seq = iprot.readI32()
+        else:
+          iprot.skip(ftype)
+      elif fid == 5:
+        if ftype == TType.STRING:
+          self.uk_name = iprot.readString()
+        else:
+          iprot.skip(ftype)
+      elif fid == 6:
+        if ftype == TType.BOOL:
+          self.enable_cstr = iprot.readBool()
+        else:
+          iprot.skip(ftype)
+      elif fid == 7:
+        if ftype == TType.BOOL:
+          self.validate_cstr = iprot.readBool()
+        else:
+          iprot.skip(ftype)
+      elif fid == 8:
+        if ftype == TType.BOOL:
+          self.rely_cstr = iprot.readBool()
         else:
           iprot.skip(ftype)
       else:
@@ -888,25 +914,38 @@ class Type:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('Type')
-    if self.name is not None:
-      oprot.writeFieldBegin('name', TType.STRING, 1)
-      oprot.writeString(self.name)
+    oprot.writeStructBegin('SQLUniqueConstraint')
+    if self.table_db is not None:
+      oprot.writeFieldBegin('table_db', TType.STRING, 1)
+      oprot.writeString(self.table_db)
       oprot.writeFieldEnd()
-    if self.type1 is not None:
-      oprot.writeFieldBegin('type1', TType.STRING, 2)
-      oprot.writeString(self.type1)
+    if self.table_name is not None:
+      oprot.writeFieldBegin('table_name', TType.STRING, 2)
+      oprot.writeString(self.table_name)
       oprot.writeFieldEnd()
-    if self.type2 is not None:
-      oprot.writeFieldBegin('type2', TType.STRING, 3)
-      oprot.writeString(self.type2)
+    if self.column_name is not None:
+      oprot.writeFieldBegin('column_name', TType.STRING, 3)
+      oprot.writeString(self.column_name)
       oprot.writeFieldEnd()
-    if self.fields is not None:
-      oprot.writeFieldBegin('fields', TType.LIST, 4)
-      oprot.writeListBegin(TType.STRUCT, len(self.fields))
-      for iter6 in self.fields:
-        iter6.write(oprot)
-      oprot.writeListEnd()
+    if self.key_seq is not None:
+      oprot.writeFieldBegin('key_seq', TType.I32, 4)
+      oprot.writeI32(self.key_seq)
+      oprot.writeFieldEnd()
+    if self.uk_name is not None:
+      oprot.writeFieldBegin('uk_name', TType.STRING, 5)
+      oprot.writeString(self.uk_name)
+      oprot.writeFieldEnd()
+    if self.enable_cstr is not None:
+      oprot.writeFieldBegin('enable_cstr', TType.BOOL, 6)
+      oprot.writeBool(self.enable_cstr)
+      oprot.writeFieldEnd()
+    if self.validate_cstr is not None:
+      oprot.writeFieldBegin('validate_cstr', TType.BOOL, 7)
+      oprot.writeBool(self.validate_cstr)
+      oprot.writeFieldEnd()
+    if self.rely_cstr is not None:
+      oprot.writeFieldBegin('rely_cstr', TType.BOOL, 8)
+      oprot.writeBool(self.rely_cstr)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
@@ -917,10 +956,14 @@ class Type:
 
   def __hash__(self):
     value = 17
-    value = (value * 31) ^ hash(self.name)
-    value = (value * 31) ^ hash(self.type1)
-    value = (value * 31) ^ hash(self.type2)
-    value = (value * 31) ^ hash(self.fields)
+    value = (value * 31) ^ hash(self.table_db)
+    value = (value * 31) ^ hash(self.table_name)
+    value = (value * 31) ^ hash(self.column_name)
+    value = (value * 31) ^ hash(self.key_seq)
+    value = (value * 31) ^ hash(self.uk_name)
+    value = (value * 31) ^ hash(self.enable_cstr)
+    value = (value * 31) ^ hash(self.validate_cstr)
+    value = (value * 31) ^ hash(self.rely_cstr)
     return value
 
   def __repr__(self):
@@ -934,31 +977,37 @@ class Type:
   def __ne__(self, other):
     return not (self == other)
 
-class HiveObjectRef:
+class SQLNotNullConstraint:
   """
   Attributes:
-   - objectType
-   - dbName
-   - objectName
-   - partValues
-   - columnName
+   - table_db
+   - table_name
+   - column_name
+   - nn_name
+   - enable_cstr
+   - validate_cstr
+   - rely_cstr
   """
 
   thrift_spec = (
     None, # 0
-    (1, TType.I32, 'objectType', None, None, ), # 1
-    (2, TType.STRING, 'dbName', None, None, ), # 2
-    (3, TType.STRING, 'objectName', None, None, ), # 3
-    (4, TType.LIST, 'partValues', (TType.STRING,None), None, ), # 4
-    (5, TType.STRING, 'columnName', None, None, ), # 5
+    (1, TType.STRING, 'table_db', None, None, ), # 1
+    (2, TType.STRING, 'table_name', None, None, ), # 2
+    (3, TType.STRING, 'column_name', None, None, ), # 3
+    (4, TType.STRING, 'nn_name', None, None, ), # 4
+    (5, TType.BOOL, 'enable_cstr', None, None, ), # 5
+    (6, TType.BOOL, 'validate_cstr', None, None, ), # 6
+    (7, TType.BOOL, 'rely_cstr', None, None, ), # 7
   )
 
-  def __init__(self, objectType=None, dbName=None, objectName=None, partValues=None, columnName=None,):
-    self.objectType = objectType
-    self.dbName = dbName
-    self.objectName = objectName
-    self.partValues = partValues
-    self.columnName = columnName
+  def __init__(self, table_db=None, table_name=None, column_name=None, nn_name=None, enable_cstr=None, validate_cstr=None, rely_cstr=None,):
+    self.table_db = table_db
+    self.table_name = table_name
+    self.column_name = column_name
+    self.nn_name = nn_name
+    self.enable_cstr = enable_cstr
+    self.validate_cstr = validate_cstr
+    self.rely_cstr = rely_cstr
 
   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:
@@ -970,33 +1019,38 @@ class HiveObjectRef:
       if ftype == TType.STOP:
         break
       if fid == 1:
-        if ftype == TType.I32:
-          self.objectType = iprot.readI32()
+        if ftype == TType.STRING:
+          self.table_db = iprot.readString()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.STRING:
-          self.dbName = iprot.readString()
+          self.table_name = iprot.readString()
         else:
           iprot.skip(ftype)
       elif fid == 3:
         if ftype == TType.STRING:
-          self.objectName = iprot.readString()
+          self.column_name = iprot.readString()
         else:
           iprot.skip(ftype)
       elif fid == 4:
-        if ftype == TType.LIST:
-          self.partValues = []
-          (_etype10, _size7) = iprot.readListBegin()
-          for _i11 in xrange(_size7):
-            _elem12 = iprot.readString()
-            self.partValues.append(_elem12)
-          iprot.readListEnd()
+        if ftype == TType.STRING:
+          self.nn_name = iprot.readString()
         else:
           iprot.skip(ftype)
       elif fid == 5:
-        if ftype == TType.STRING:
-          self.columnName = iprot.readString()
+        if ftype == TType.BOOL:
+          self.enable_cstr = iprot.readBool()
+        else:
+          iprot.skip(ftype)
+      elif fid == 6:
+        if ftype == TType.BOOL:
+          self.validate_cstr = iprot.readBool()
+        else:
+          iprot.skip(ftype)
+      elif fid == 7:
+        if ftype == TType.BOOL:
+          self.rely_cstr = iprot.readBool()
         else:
           iprot.skip(ftype)
       else:
@@ -1008,29 +1062,34 @@ class HiveObjectRef:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('HiveObjectRef')
-    if self.objectType is not None:
-      oprot.writeFieldBegin('objectType', TType.I32, 1)
-      oprot.writeI32(self.objectType)
+    oprot.writeStructBegin('SQLNotNullConstraint')
+    if self.table_db is not None:
+      oprot.writeFieldBegin('table_db', TType.STRING, 1)
+      oprot.writeString(self.table_db)
       oprot.writeFieldEnd()
-    if self.dbName is not None:
-      oprot.writeFieldBegin('dbName', TType.STRING, 2)
-      oprot.writeString(self.dbName)
+    if self.table_name is not None:
+      oprot.writeFieldBegin('table_name', TType.STRING, 2)
+      oprot.writeString(self.table_name)
       oprot.writeFieldEnd()
-    if self.objectName is not None:
-      oprot.writeFieldBegin('objectName', TType.STRING, 3)
-      oprot.writeString(self.objectName)
+    if self.column_name is not None:
+      oprot.writeFieldBegin('column_name', TType.STRING, 3)
+      oprot.writeString(self.column_name)
       oprot.writeFieldEnd()
-    if self.partValues is not None:
-      oprot.writeFieldBegin('partValues', TType.LIST, 4)
-      oprot.writeListBegin(TType.STRING, len(self.partValues))
-      for iter13 in self.partValues:
-        oprot.writeString(iter13)
-      oprot.writeListEnd()
+    if self.nn_name is not None:
+      oprot.writeFieldBegin('nn_name', TType.STRING, 4)
+      oprot.writeString(self.nn_name)
       oprot.writeFieldEnd()
-    if self.columnName is not None:
-      oprot.writeFieldBegin('columnName', TType.STRING, 5)
-      oprot.writeString(self.columnName)
+    if self.enable_cstr is not None:
+      oprot.writeFieldBegin('enable_cstr', TType.BOOL, 5)
+      oprot.writeBool(self.enable_cstr)
+      oprot.writeFieldEnd()
+    if self.validate_cstr is not None:
+      oprot.writeFieldBegin('validate_cstr', TType.BOOL, 6)
+      oprot.writeBool(self.validate_cstr)
+      oprot.writeFieldEnd()
+    if self.rely_cstr is not None:
+      oprot.writeFieldBegin('rely_cstr', TType.BOOL, 7)
+      oprot.writeBool(self.rely_cstr)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
@@ -1041,11 +1100,13 @@ class HiveObjectRef:
 
   def __hash__(self):
     value = 17
-    value = (value * 31) ^ hash(self.objectType)
-    value = (value * 31) ^ hash(self.dbName)
-    value = (value * 31) ^ hash(self.objectName)
-    value = (value * 31) ^ hash(self.partValues)
-    value = (value * 31) ^ hash(self.columnName)
+    value = (value * 31) ^ hash(self.table_db)
+    value = (value * 31) ^ hash(self.table_name)
+    value = (value * 31) ^ hash(self.column_name)
+    value = (value * 31) ^ hash(self.nn_name)
+    value = (value * 31) ^ hash(self.enable_cstr)
+    value = (value * 31) ^ hash(self.validate_cstr)
+    value = (value * 31) ^ hash(self.rely_cstr)
     return value
 
   def __repr__(self):
@@ -1059,30 +1120,268 @@ class HiveObjectRef:
   def __ne__(self, other):
     return not (self == other)
 
-class PrivilegeGrantInfo:
+class Type:
   """
   Attributes:
-   - privilege
-   - createTime
-   - grantor
-   - grantorType
-   - grantOption
+   - name
+   - type1
+   - type2
+   - fields
   """
 
   thrift_spec = (
     None, # 0
-    (1, TType.STRING, 'privilege', None, None, ), # 1
-    (2, TType.I32, 'createTime', None, None, ), # 2
-    (3, TType.STRING, 'grantor', None, None, ), # 3
-    (4, TType.I32, 'grantorType', None, None, ), # 4
-    (5, TType.BOOL, 'grantOption', None, None, ), # 5
+    (1, TType.STRING, 'name', None, None, ), # 1
+    (2, TType.STRING, 'type1', None, None, ), # 2
+    (3, TType.STRING, 'type2', None, None, ), # 3
+    (4, TType.LIST, 'fields', (TType.STRUCT,(FieldSchema, FieldSchema.thrift_spec)), None, ), # 4
   )
 
-  def __init__(self, privilege=None, createTime=None, grantor=None, grantorType=None, grantOption=None,):
-    self.privilege = privilege
-    self.createTime = createTime
-    self.grantor = grantor
-    self.grantorType = grantorType
+  def __init__(self, name=None, type1=None, type2=None, fields=None,):
+    self.name = name
+    self.type1 = type1
+    self.type2 = type2
+    self.fields = fields
+
+  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:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRING:
+          self.name = iprot.readString()
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRING:
+          self.type1 = iprot.readString()
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.STRING:
+          self.type2 = iprot.readString()
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
+        if ftype == TType.LIST:
+          self.fields = []
+          (_etype3, _size0) = iprot.readListBegin()
+          for _i4 in xrange(_size0):
+            _elem5 = FieldSchema()
+            _elem5.read(iprot)
+            self.fields.append(_elem5)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('Type')
+    if self.name is not None:
+      oprot.writeFieldBegin('name', TType.STRING, 1)
+      oprot.writeString(self.name)
+      oprot.writeFieldEnd()
+    if self.type1 is not None:
+      oprot.writeFieldBegin('type1', TType.STRING, 2)
+      oprot.writeString(self.type1)
+      oprot.writeFieldEnd()
+    if self.type2 is not None:
+      oprot.writeFieldBegin('type2', TType.STRING, 3)
+      oprot.writeString(self.type2)
+      oprot.writeFieldEnd()
+    if self.fields is not None:
+      oprot.writeFieldBegin('fields', TType.LIST, 4)
+      oprot.writeListBegin(TType.STRUCT, len(self.fields))
+      for iter6 in self.fields:
+        iter6.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    return
+
+
+  def __hash__(self):
+    value = 17
+    value = (value * 31) ^ hash(self.name)
+    value = (value * 31) ^ hash(self.type1)
+    value = (value * 31) ^ hash(self.type2)
+    value = (value * 31) ^ hash(self.fields)
+    return value
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class HiveObjectRef:
+  """
+  Attributes:
+   - objectType
+   - dbName
+   - objectName
+   - partValues
+   - columnName
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.I32, 'objectType', None, None, ), # 1
+    (2, TType.STRING, 'dbName', None, None, ), # 2
+    (3, TType.STRING, 'objectName', None, None, ), # 3
+    (4, TType.LIST, 'partValues', (TType.STRING,None), None, ), # 4
+    (5, TType.STRING, 'columnName', None, None, ), # 5
+  )
+
+  def __init__(self, objectType=None, dbName=None, objectName=None, partValues=None, columnName=None,):
+    self.objectType = objectType
+    self.dbName = dbName
+    self.objectName = objectName
+    self.partValues = partValues
+    self.columnName = columnName
+
+  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:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I32:
+          self.objectType = iprot.readI32()
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRING:
+          self.dbName = iprot.readString()
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.STRING:
+          self.objectName = iprot.readString()
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
+        if ftype == TType.LIST:
+          self.partValues = []
+          (_etype10, _size7) = iprot.readListBegin()
+          for _i11 in xrange(_size7):
+            _elem12 = iprot.readString()
+            self.partValues.append(_elem12)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 5:
+        if ftype == TType.STRING:
+          self.columnName = iprot.readString()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('HiveObjectRef')
+    if self.objectType is not None:
+      oprot.writeFieldBegin('objectType', TType.I32, 1)
+      oprot.writeI32(self.objectType)
+      oprot.writeFieldEnd()
+    if self.dbName is not None:
+      oprot.writeFieldBegin('dbName', TType.STRING, 2)
+      oprot.writeString(self.dbName)
+      oprot.writeFieldEnd()
+    if self.objectName is not None:
+      oprot.writeFieldBegin('objectName', TType.STRING, 3)
+      oprot.writeString(self.objectName)
+      oprot.writeFieldEnd()
+    if self.partValues is not None:
+      oprot.writeFieldBegin('partValues', TType.LIST, 4)
+      oprot.writeListBegin(TType.STRING, len(self.partValues))
+      for iter13 in self.partValues:
+        oprot.writeString(iter13)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.columnName is not None:
+      oprot.writeFieldBegin('columnName', TType.STRING, 5)
+      oprot.writeString(self.columnName)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    return
+
+
+  def __hash__(self):
+    value = 17
+    value = (value * 31) ^ hash(self.objectType)
+    value = (value * 31) ^ hash(self.dbName)
+    value = (value * 31) ^ hash(self.objectName)
+    value = (value * 31) ^ hash(self.partValues)
+    value = (value * 31) ^ hash(self.columnName)
+    return value
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class PrivilegeGrantInfo:
+  """
+  Attributes:
+   - privilege
+   - createTime
+   - grantor
+   - grantorType
+   - grantOption
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'privilege', None, None, ), # 1
+    (2, TType.I32, 'createTime', None, None, ), # 2
+    (3, TType.STRING, 'grantor', None, None, ), # 3
+    (4, TType.I32, 'grantorType', None, None, ), # 4
+    (5, TType.BOOL, 'grantOption', None, None, ), # 5
+  )
+
+  def __init__(self, privilege=None, createTime=None, grantor=None, grantorType=None, grantOption=None,):
+    self.privilege = privilege
+    self.createTime = createTime
+    self.grantor = grantor
+    self.grantorType = grantorType
     self.grantOption = grantOption
 
   def read(self, iprot):
@@ -5379,28 +5678,423 @@ class ColumnStatisticsObj:
       oprot.writeFieldBegin('colType', TType.STRING, 2)
       oprot.writeString(self.colType)
       oprot.writeFieldEnd()
-    if self.statsData is not None:
-      oprot.writeFieldBegin('statsData', TType.STRUCT, 3)
-      self.statsData.write(oprot)
+    if self.statsData is not None:
+      oprot.writeFieldBegin('statsData', TType.STRUCT, 3)
+      self.statsData.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    if self.colName is None:
+      raise TProtocol.TProtocolException(message='Required field colName is unset!')
+    if self.colType is None:
+      raise TProtocol.TProtocolException(message='Required field colType is unset!')
+    if self.statsData is None:
+      raise TProtocol.TProtocolException(message='Required field statsData is unset!')
+    return
+
+
+  def __hash__(self):
+    value = 17
+    value = (value * 31) ^ hash(self.colName)
+    value = (value * 31) ^ hash(self.colType)
+    value = (value * 31) ^ hash(self.statsData)
+    return value
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class ColumnStatisticsDesc:
+  """
+  Attributes:
+   - isTblLevel
+   - dbName
+   - tableName
+   - partName
+   - lastAnalyzed
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.BOOL, 'isTblLevel', None, None, ), # 1
+    (2, TType.STRING, 'dbName', None, None, ), # 2
+    (3, TType.STRING, 'tableName', None, None, ), # 3
+    (4, TType.STRING, 'partName', None, None, ), # 4
+    (5, TType.I64, 'lastAnalyzed', None, None, ), # 5
+  )
+
+  def __init__(self, isTblLevel=None, dbName=None, tableName=None, partName=None, lastAnalyzed=None,):
+    self.isTblLevel = isTblLevel
+    self.dbName = dbName
+    self.tableName = tableName
+    self.partName = partName
+    self.lastAnalyzed = lastAnalyzed
+
+  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:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.BOOL:
+          self.isTblLevel = iprot.readBool()
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRING:
+          self.dbName = iprot.readString()
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.STRING:
+          self.tableName = iprot.readString()
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
+        if ftype == TType.STRING:
+          self.partName = iprot.readString()
+        else:
+          iprot.skip(ftype)
+      elif fid == 5:
+        if ftype == TType.I64:
+          self.lastAnalyzed = iprot.readI64()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('ColumnStatisticsDesc')
+    if self.isTblLevel is not None:
+      oprot.writeFieldBegin('isTblLevel', TType.BOOL, 1)
+      oprot.writeBool(self.isTblLevel)
+      oprot.writeFieldEnd()
+    if self.dbName is not None:
+      oprot.writeFieldBegin('dbName', TType.STRING, 2)
+      oprot.writeString(self.dbName)
+      oprot.writeFieldEnd()
+    if self.tableName is not None:
+      oprot.writeFieldBegin('tableName', TType.STRING, 3)
+      oprot.writeString(self.tableName)
+      oprot.writeFieldEnd()
+    if self.partName is not None:
+      oprot.writeFieldBegin('partName', TType.STRING, 4)
+      oprot.writeString(self.partName)
+      oprot.writeFieldEnd()
+    if self.lastAnalyzed is not None:
+      oprot.writeFieldBegin('lastAnalyzed', TType.I64, 5)
+      oprot.writeI64(self.lastAnalyzed)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    if self.isTblLevel is None:
+      raise TProtocol.TProtocolException(message='Required field isTblLevel is unset!')
+    if self.dbName is None:
+      raise TProtocol.TProtocolException(message='Required field dbName is unset!')
+    if self.tableName is None:
+      raise TProtocol.TProtocolException(message='Required field tableName is unset!')
+    return
+
+
+  def __hash__(self):
+    value = 17
+    value = (value * 31) ^ hash(self.isTblLevel)
+    value = (value * 31) ^ hash(self.dbName)
+    value = (value * 31) ^ hash(self.tableName)
+    value = (value * 31) ^ hash(self.partName)
+    value = (value * 31) ^ hash(self.lastAnalyzed)
+    return value
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class ColumnStatistics:
+  """
+  Attributes:
+   - statsDesc
+   - statsObj
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'statsDesc', (ColumnStatisticsDesc, ColumnStatisticsDesc.thrift_spec), None, ), # 1
+    (2, TType.LIST, 'statsObj', (TType.STRUCT,(ColumnStatisticsObj, ColumnStatisticsObj.thrift_spec)), None, ), # 2
+  )
+
+  def __init__(self, statsDesc=None, statsObj=None,):
+    self.statsDesc = statsDesc
+    self.statsObj = statsObj
+
+  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:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRUCT:
+          self.statsDesc = ColumnStatisticsDesc()
+          self.statsDesc.read(iprot)
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.LIST:
+          self.statsObj = []
+          (_etype242, _size239) = iprot.readListBegin()
+          for _i243 in xrange(_size239):
+            _elem244 = ColumnStatisticsObj()
+            _elem244.read(iprot)
+            self.statsObj.append(_elem244)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('ColumnStatistics')
+    if self.statsDesc is not None:
+      oprot.writeFieldBegin('statsDesc', TType.STRUCT, 1)
+      self.statsDesc.write(oprot)
+      oprot.writeFieldEnd()
+    if self.statsObj is not None:
+      oprot.writeFieldBegin('statsObj', TType.LIST, 2)
+      oprot.writeListBegin(TType.STRUCT, len(self.statsObj))
+      for iter245 in self.statsObj:
+        iter245.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    if self.statsDesc is None:
+      raise TProtocol.TProtocolException(message='Required field statsDesc is unset!')
+    if self.statsObj is None:
+      raise TProtocol.TProtocolException(message='Required field statsObj is unset!')
+    return
+
+
+  def __hash__(self):
+    value = 17
+    value = (value * 31) ^ hash(self.statsDesc)
+    value = (value * 31) ^ hash(self.statsObj)
+    return value
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class AggrStats:
+  """
+  Attributes:
+   - colStats
+   - partsFound
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.LIST, 'colStats', (TType.STRUCT,(ColumnStatisticsObj, ColumnStatisticsObj.thrift_spec)), None, ), # 1
+    (2, TType.I64, 'partsFound', None, None, ), # 2
+  )
+
+  def __init__(self, colStats=None, partsFound=None,):
+    self.colStats = colStats
+    self.partsFound = partsFound
+
+  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:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.LIST:
+          self.colStats = []
+          (_etype249, _size246) = iprot.readListBegin()
+          for _i250 in xrange(_size246):
+            _elem251 = ColumnStatisticsObj()
+            _elem251.read(iprot)
+            self.colStats.append(_elem251)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I64:
+          self.partsFound = iprot.readI64()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('AggrStats')
+    if self.colStats is not None:
+      oprot.writeFieldBegin('colStats', TType.LIST, 1)
+      oprot.writeListBegin(TType.STRUCT, len(self.colStats))
+      for iter252 in self.colStats:
+        iter252.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.partsFound is not None:
+      oprot.writeFieldBegin('partsFound', TType.I64, 2)
+      oprot.writeI64(self.partsFound)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    if self.colStats is None:
+      raise TProtocol.TProtocolException(message='Required field colStats is unset!')
+    if self.partsFound is None:
+      raise TProtocol.TProtocolException(message='Required field partsFound is unset!')
+    return
+
+
+  def __hash__(self):
+    value = 17
+    value = (value * 31) ^ hash(self.colStats)
+    value = (value * 31) ^ hash(self.partsFound)
+    return value
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class SetPartitionsStatsRequest:
+  """
+  Attributes:
+   - colStats
+   - needMerge
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.LIST, 'colStats', (TType.STRUCT,(ColumnStatistics, ColumnStatistics.thrift_spec)), None, ), # 1
+    (2, TType.BOOL, 'needMerge', None, None, ), # 2
+  )
+
+  def __init__(self, colStats=None, needMerge=None,):
+    self.colStats = colStats
+    self.needMerge = needMerge
+
+  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:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.LIST:
+          self.colStats = []
+          (_etype256, _size253) = iprot.readListBegin()
+          for _i257 in xrange(_size253):
+            _elem258 = ColumnStatistics()
+            _elem258.read(iprot)
+            self.colStats.append(_elem258)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.BOOL:
+          self.needMerge = iprot.readBool()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('SetPartitionsStatsRequest')
+    if self.colStats is not None:
+      oprot.writeFieldBegin('colStats', TType.LIST, 1)
+      oprot.writeListBegin(TType.STRUCT, len(self.colStats))
+      for iter259 in self.colStats:
+        iter259.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.needMerge is not None:
+      oprot.writeFieldBegin('needMerge', TType.BOOL, 2)
+      oprot.writeBool(self.needMerge)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
 
   def validate(self):
-    if self.colName is None:
-      raise TProtocol.TProtocolException(message='Required field colName is unset!')
-    if self.colType is None:
-      raise TProtocol.TProtocolException(message='Required field colType is unset!')
-    if self.statsData is None:
-      raise TProtocol.TProtocolException(message='Required field statsData is unset!')
+    if self.colStats is None:
+      raise TProtocol.TProtocolException(message='Required field colStats is unset!')
     return
 
 
   def __hash__(self):
     value = 17
-    value = (value * 31) ^ hash(self.colName)
-    value = (value * 31) ^ hash(self.colType)
-    value = (value * 31) ^ hash(self.statsData)
+    value = (value * 31) ^ hash(self.colStats)
+    value = (value * 31) ^ hash(self.needMerge)
     return value
 
   def __repr__(self):
@@ -5414,31 +6108,22 @@ class ColumnStatisticsObj:
   def __ne__(self, other):
     return not (self == other)
 
-class ColumnStatisticsDesc:
+class Schema:
   """
   Attributes:
-   - isTblLevel
-   - dbName
-   - tableName
-   - partName
-   - lastAnalyzed
+   - fieldSchemas
+   - properties
   """
 
   thrift_spec = (
     None, # 0
-    (1, TType.BOOL, 'isTblLevel', None, None, ), # 1
-    (2, TType.STRING, 'dbName', None, None, ), # 2
-    (3, TType.STRING, 'tableName', None, None, ), # 3
-    (4, TType.STRING, 'partName', None, None, ), # 4
-    (5, TType.I64, 'lastAnalyzed', None, None, ), # 5
+    (1, TType.LIST, 'fieldSchemas', (TType.STRUCT,(FieldSchema, FieldSchema.thrift_spec)), None, ), # 1
+    (2, TType.MAP, 'properties', (TType.STRING,None,TType.STRING,None), None, ), # 2
   )
 
-  def __init__(self, isTblLevel=None, dbName=None, tableName=None, partName=None, lastAnalyzed=None,):
-    self.isTblLevel = isTblLevel
-    self.dbName = dbName
-    self.tableName = tableName
-    self.partName = partName
-    self.lastAnalyzed = lastAnalyzed
+  def __init__(self, fieldSchemas=None, properties=None,):
+    self.fieldSchemas = fieldSchemas
+    self.properties = properties
 
   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:
@@ -5450,28 +6135,25 @@ class ColumnStatisticsDesc:
       if ftype == TType.STOP:
         break
       if fid == 1:
-        if ftype == TType.BOOL:
-          self.isTblLevel = iprot.readBool()
+        if ftype == TType.LIST:
+          self.fieldSchemas = []
+          (_etype263, _size260) = iprot.readListBegin()
+          for _i264 in xrange(_size260):
+            _elem265 = FieldSchema()
+            _elem265.read(iprot)
+            self.fieldSchemas.append(_elem265)
+          iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
-        if ftype == TType.STRING:
-          self.dbName = iprot.readString()
-        else:
-          iprot.skip(ftype)
-      elif fid == 3:
-        if ftype == TType.STRING:
-          self.tableName = iprot.readString()
-        else:
-          iprot.skip(ftype)
-      elif fid == 4:
-        if ftype == TType.STRING:
-          self.partName = iprot.readString()
-        else:
-          iprot.skip(ftype)
-      elif fid == 5:
-        if ftype == TType.I64:
-          self.lastAnalyzed = iprot.readI64()
+        if ftype == TType.MAP:
+          self.properties = {}
+          (_ktype267, _vtype268, _size266 ) = iprot.readMapBegin()
+          for _i270 in xrange(_size266):
+            _key271 = iprot.readString()
+            _val272 = iprot.readString()
+            self.properties[_key271] = _val272
+          iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
@@ -5483,47 +6165,33 @@ class ColumnStatisticsDesc:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('ColumnStatisticsDesc')
-    if self.isTblLevel is not None:
-      oprot.writeFieldBegin('isTblLevel', TType.BOOL, 1)
-      oprot.writeBool(self.isTblLevel)
-      oprot.writeFieldEnd()
-    if self.dbName is not None:
-      oprot.writeFieldBegin('dbName', TType.STRING, 2)
-      oprot.writeString(self.dbName)
-      oprot.writeFieldEnd()
-    if self.tableName is not None:
-      oprot.writeFieldBegin('tableName', TType.STRING, 3)
-      oprot.writeString(self.tableName)
-      oprot.writeFieldEnd()
-    if self.partName is not None:
-      oprot.writeFieldBegin('partName', TType.STRING, 4)
-      oprot.writeString(self.partName)
+    oprot.writeStructBegin('Schema')
+    if self.fieldSchemas is not None:
+      oprot.writeFieldBegin('fieldSchemas', TType.LIST, 1)
+      oprot.writeListBegin(TType.STRUCT, len(self.fieldSchemas))
+      for iter273 in self.fieldSchemas:
+        iter273.write(oprot)
+      oprot.writeListEnd()
       oprot.writeFieldEnd()
-    if self.lastAnalyzed is not None:
-      oprot.writeFieldBegin('lastAnalyzed', TType.I64, 5)
-      oprot.writeI64(self.lastAnalyzed)
+    if self.properties is not None:
+      oprot.writeFieldBegin('properties', TType.MAP, 2)
+      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.properties))
+      for kiter274,viter275 in self.properties.items():
+        oprot.writeString(kiter274)
+        oprot.writeString(viter275)
+      oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
 
   def validate(self):
-    if self.isTblLevel is None:
-      raise TProtocol.TProtocolException(message='Required field isTblLevel is unset!')
-    if self.dbName is None:
-      raise TProtocol.TProtocolException(message='Required field dbName is unset!')
-    if self.tableName is None:
-      raise TProtocol.TProtocolException(message='Required field tableName is unset!')
     return
 
 
   def __hash__(self):
     value = 17
-    value = (value * 31) ^ hash(self.isTblLevel)
-    value = (value * 31) ^ hash(self.dbName)
-    value = (value * 31) ^ hash(self.tableName)
-    value = (value * 31) ^ hash(self.partName)
-    value = (value * 31) ^ hash(self.lastAnalyzed)
+    value = (value * 31) ^ hash(self.fieldSchemas)
+    value = (value * 31) ^ hash(self.properties)
     return value
 
   def __repr__(self):
@@ -5537,22 +6205,19 @@ class ColumnStatisticsDesc:
   def __ne__(self, other):
     return not (self == other)
 
-class ColumnStatistics:
+class EnvironmentContext:
   """
   Attributes:
-   - statsDesc
-   - statsObj
+   - properties
   """
 
   thrift_spec = (
     None, # 0
-    (1, TType.STRUCT, 'statsDesc', (ColumnStatisticsDesc, ColumnStatisticsDesc.thrift_spec), None, ), # 1
-    (2, TType.LIST, 'statsObj', (TType.STRUCT,(ColumnStatisticsObj, ColumnStatisticsObj.thrift_spec)), None, ), # 2
+    (1, TType.MAP, 'properties', (TType.STRING,None,TType.STRING,None), None, ), # 1
   )
 
-  def __init__(self, statsDesc=None, statsObj=None,):
-    self.statsDesc = statsDesc
-    self.statsObj = statsObj
+  def __init__(self, properties=None,):
+    self.properties = properties
 
   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:
@@ -5564,20 +6229,14 @@ class ColumnStatistics:
       if ftype == TType.STOP:
         break
       if fid == 1:
-        if ftype == TType.STRUCT:
-          self.statsDesc = ColumnStatisticsDesc()
-          self.statsDesc.read(iprot)
-        else:
-          iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.LIST:
-          self.statsObj = []
-          (_etype242, _size239) = iprot.readListBegin()
-          for _i243 in xrange(_size239):
-            _elem244 = ColumnStatisticsObj()
-            _elem244.read(iprot)
-            self.statsObj.append(_elem244)
-          iprot.readListEnd()
+        if ftype == TType.MAP:
+          self.properties = {}
+          (_ktype277, _vtype278, _size276 ) = iprot.readMapBegin()
+          for _i280 in xrange(_size276):
+            _key281 = iprot.readString()
+            _val282 = iprot.readString()
+            self.properties[_key281] = _val282
+          iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
@@ -5589,33 +6248,25 @@ class ColumnStatistics:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('ColumnStatistics')
-    if self.statsDesc is not None:
-      oprot.writeFieldBegin('statsDesc', TType.STRUCT, 1)
-      self.statsDesc.write(oprot)
-      oprot.writeFieldEnd()
-    if self.statsObj is not None:
-      oprot.writeFieldBegin('statsObj', TType.LIST, 2)
-      oprot.writeListBegin(TType.STRUCT, len(self.statsObj))
-      for iter245 in self.statsObj:
-        iter245.write(oprot)
-      oprot.writeListEnd()
+    oprot.writeStructBegin('EnvironmentContext')
+    if self.properties is not None:
+      oprot.writeFieldBegin('properties', TType.MAP, 1)
+      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.properties))
+      for kiter283,viter284 in self.properties.items():
+        oprot.writeString(kiter283)
+        oprot.writeString(viter284)
+      oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
 
   def validate(self):
-    if self.statsDesc is None:
-      raise TProtocol.TProtocolException(message='Required field statsDesc is unset!')
-    if self.statsObj is None:
-      raise TProtocol.TProtocolException(message='Required field statsObj is unset!')
     return
 
 
   def __hash__(self):
     value = 17
-    value = (value * 31) ^ hash(self.statsDesc)
-    value = (value * 31) ^ hash(self.statsObj)
+    value = (value * 31) ^ hash(self.properties)
     return value
 
   def __repr__(self):
@@ -5629,22 +6280,22 @@ class ColumnStatistics:
   def __ne__(self, other):
     return not (self == other)
 
-class AggrStats:
+class PrimaryKeysRequest:
   """
   Attributes:
-   - colStats
-   - partsFound
+   - db_name
+   - tbl_name
   """
 
   thrift_spec = (
     None, # 0
-    (1, TType.LIST, 'colStats', (TType.STRUCT,(ColumnStatisticsObj, ColumnStatisticsObj.thrift_spec)), None, ), # 1
-    (2, TType.I64, 'partsFound', None, None, ), # 2
+    (1, TType.STRING, 'db_name', None, None, ), # 1
+    (2, TType.STRING, 'tbl_name', None, None, ), # 2
   )
 
-  def __init__(self, colStats=None, partsFound=None,):
-    self.colStats = colStats
-    self.partsFound = partsFound
+  def __init__(self, db_name=None, tbl_name=None,):
+    self.db_name = db_name
+    self.tbl_name = tbl_name
 
   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:
@@ -5656,19 +6307,13 @@ class AggrStats:
       if ftype == TType.STOP:
         break
       if fid == 1:
-        if ftype == TType.LIST:
-          self.colStats = []
-          (_etype249, _size246) = iprot.readListBegin()
-          for _i250 in xrange(_size246):
-            _elem251 = ColumnStatisticsObj()
-            _elem251.read(iprot)
-            self.colStats.append(_elem251)
-          iprot.readListEnd()
+        if ftype == TType.STRING:
+          self.db_name = iprot.readString()
         else:
           iprot.skip(ftype)
       elif fid == 2:
-        if ftype == TType.I64:
-          self.partsFound = iprot.readI64()
+        if ftype == TType.STRING:
+          self.tbl_name = iprot.readString()
         else:
           iprot.skip(ftype)
       else:
@@ -5680,33 +6325,30 @@ class AggrStats:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('AggrStats')
-    if self.colStats is not None:
-      oprot.writeFieldBegin('colStats', TType.LIST, 1)
-      oprot.writeListBegin(TType.STRUCT, len(self.colStats))
-      for iter252 in self.colStats:
-        iter252.write(oprot)
-      oprot.writeListEnd()
+    oprot.writeStructBegin('PrimaryKeysRequest')
+    if self.db_name is not None:
+      oprot.writeFieldBegin('db_name', TType.STRING, 1)
+      oprot.writeString(self.db_name)
       oprot.writeFieldEnd()
-    if self.partsFound is not None:
-      oprot.writeFieldBegin('partsFound', TType.I64, 2)
-      oprot.writeI64(self.partsFound)
+    if self.tbl_name is not None:
+      oprot.writeFieldBegin('tbl_name', TType.STRING, 2)
+      oprot.writeString(self.tbl_name)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
 
   def validate(self):
-    if self.colStats is None:
-      raise TProtocol.TProtocolException(message='Required field colStats is unset!')
-    if self.partsFound is None:
-      raise TProtocol.TProtocolException(message='Required field partsFound is unset!')
+    if self.db_name is None:
+      raise TProtocol.TProtocolException(message='Required field db_name is unset!')
+    if self.tbl_name is None:
+      raise TProtocol.TProtocolException(message='Required field tbl_name is unset!')
     return
 
 
   def __hash__(self):
     value = 17
-    value = (value * 31) ^ hash(self.colStats)
-    value = (value * 31) ^ hash(self.partsFound)
+    value = (value * 31) ^ hash(self.db_name)
+    value = (value * 31) ^ hash(self.tbl_name)
     return value
 
   def __repr__(self):
@@ -5720,22 +6362,19 @@ class AggrStats:
   def __ne__(self, other):
     return not (self == other)
 
-class SetPartitionsStatsRequest:
+class PrimaryKeysResponse:
   """
   Attributes:
-   - colStats
-   - needMerge
+   - primaryKeys
   """
 
   thrift_spec = (
     None, # 0
-    (1, TType.LIST, 'colStats', (TType.STRUCT,(ColumnStatistics, ColumnStatistics.thrift_spec)), None, ), # 1
-    (2, TType.BOOL, 'needMerge', None, None, ), # 2
+    (1, TType.LIST, 'primaryKeys', (TType.STRUCT,(SQLPrimaryKey, SQLPrimaryKey.thrift_spec)), None, ), # 1
   )
 
-  def __init__(self, colStats=None, needMerge=None,):
-    self.colStats = colStats
-    self.needMerge = needMerge
+  def __init__(self, primaryKeys=None,):
+    self.primaryKeys = primaryKeys
 
   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:
@@ -5748,20 +6387,15 @@ class SetPartitionsStatsRequest:
         break
       if fid == 1:
         if ftype == TType.LIST:
-          self.colStats = []
-          (_etype256, _size253) = iprot.readListBegin()
-          for _i257 in xrange(_size253):
-            _elem258 = ColumnStatistics()
-            _elem258.read(iprot)
-            self.colStats.append(_elem258)
+          self.primaryKeys = []
+          (_etype288, _size285) = iprot.readListBegin()
+          for _i289 in xrange(_size285):
+            _elem290 = SQLPrimaryKey()
+            _elem290.read(iprot)
+            self.primaryKeys.append(_elem290)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.BOOL:
-          self.needMerge = iprot.readBool()
-        else:
-          iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
@@ -5771,31 +6405,26 @@ class SetPartitionsStatsRequest:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('SetPartitionsStatsRequest')
-    if self.colStats is not None:
-      oprot.writeFieldBegin('colStats', TType.LIST, 1)
-      oprot.writeListBegin(TType.STRUCT, len(self.colStats))
-      for iter259 in self.colStats:
-        iter259.write(oprot)
+    oprot.writeStructBegin('PrimaryKeysResponse')
+    if self.primaryKeys is not None:
+      oprot.writeFieldBegin('primaryKeys', TType.LIST, 1)
+      oprot.writeListBegin(TType.STRUCT, len(self.primaryKeys))
+      for iter291 in self.primaryKeys:
+        iter291.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
-    if self.needMerge is not None:
-      oprot.writeFieldBegin('needMerge', TType.BOOL, 2)
-      oprot.writeBool(self.needMerge)
-      oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
 
   def validate(self):
-    if self.colStats is None:
-      raise TProtocol.TProtocolException(message='Required field colStats is unset!')
+    if self.primaryKeys is None:
+      raise TProtocol.TProtocolException(message='Required field primaryKeys is unset!')
     return
 
 
   def __hash__(self):
     value = 17
-    value = (value * 31) ^ hash(self.colStats)
-    value = (value * 31) ^ hash(self.needMerge)
+    value = (value * 31) ^ hash(self.primaryKeys)
     return value
 
   def __repr__(self):
@@ -5809,22 +6438,28 @@ class SetPartitionsStatsRequest:
   def __ne__(self, other):
     return not (self == other)
 
-class Schema:
+class ForeignKeysRequest:
   """
   Attributes:
-   - fieldSchemas
-   - properties
+   - parent_db_name
+   - parent_tbl_name
+   - foreign_db_name
+   - foreign_tbl_name
   """
 
   thrift_spec = (
     None, # 0
-    (1, TType.LIST, 'fieldSchemas', (TType.STRUCT,(FieldSchema, FieldSchema.thrift_spec)), None, ), # 1
-    (2, TType.MAP, 'properties', (TType.STRING,None,TType.STRING,None), None, ), # 2
+    (1, TType.STRING, 'parent_db_name', None, None, ), # 1
+    (2, TType.STRING, 'parent_tbl_name', None, None, ), # 2
+    (3, TType.STRING, 'foreign_db_name', None, None, ), # 3
+    (4, TType.STRING, 'foreign_tbl_name', None, None, ), # 4
   )
 
-  def __init__(self, fieldSchemas=None, properties=None,):
-    self.fieldSchemas = fieldSchemas
-    self.properties = properties
+  def __init__(self, parent_db_name=None, parent_tbl_name=None, foreign_db_name=None, foreign_tbl_name=None,):
+    self.parent_db_name = parent_db_name
+    self.parent_tbl_name = parent_tbl_name
+    self.foreign_db_name = foreign_db_name
+    self.foreign_tbl_name = foreign_tbl_name
 
   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:
@@ -5836,25 +6471,23 @@ class Schema:
       if ftype == TType.STOP:
         break
       if fid == 1:
-        if ftype == TType.LIST:
-          self.fieldSchemas = []
-          (_etype263, _size260) = iprot.readListBegin()
-          for _i264 in xrange(_size260):
-            _elem265 = FieldSchema()
-            _elem265.read(iprot)
-            self.fieldSchemas.append(_elem265)
-          iprot.readListEnd()
+        if ftype == TType.STRING:
+          self.parent_db_name = iprot.readString()
         else:
           iprot.skip(ftype)
       elif fid == 2:
-        if ftype == TType.MAP:
-          self.properties = {}
-          (_ktype267, _vtype268, _size266 ) = iprot.readMapBegin()
-          for _i270 in xrange(_size266):
-            _key271 = iprot.readString()
-            _val272 = iprot.readString()
-            self.properties[_key271] = _val272
-          iprot.readMapEnd()
+        if ftype == TType.STRING:
+          self.parent_tbl_name = iprot.readString()
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.STRING:
+          self.foreign_db_name = iprot.readString()
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
+        if ftype == TType.STRING:
+          self.foreign_tbl_name = iprot.readString()
         else:
           iprot.skip(ftype)
       else:
@@ -5866,21 +6499,22 @@ class Schema:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('Schema')
-    if self.fieldSchemas is not None:
-      oprot.writeFieldBegin('fieldSchemas', TType.LIST, 1)
-      oprot.writeListBegin(TType.STRUCT, len(self.fieldSchemas))
-      for iter273 in self.fieldSchemas:
-        iter273.write(oprot)
-      oprot.writeListEnd()
+    oprot.writeStructBegin('ForeignKeysRequest')
+    if self.parent_db_name is not None:
+      oprot.writeFieldBegin('parent_db_name', TType.STRING, 1)
+      oprot.writeString(self.parent_db_name)
       oprot.writeFieldEnd()
-    if self.properties is not None:
-      oprot.writeFieldBegin('properties', TType.MAP, 2)
-      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.properties))
-      for kiter274,viter275 in self.properties.items():
-        oprot.writeString(kiter274)
-        oprot.writeString(viter275)
-      oprot.writeMapEnd()
+    if self.parent_tbl_name is not None:
+      oprot.writeFieldBegin('parent_tbl_name', TType.STRING, 2)
+      oprot.writeString(self.parent_tbl_name)
+      oprot.writeFieldEnd()
+    if self.foreign_db_name is not None:
+      oprot.writeFieldBegin('foreign_db_name', TType.STRING, 3)
+      oprot.writeString(self.foreign_db_name)
+      oprot.writeFieldEnd()
+    if self.foreign_tbl_name is not None:
+      oprot.writeFieldBegin('foreign_tbl_name', TType.STRING, 4)
+      oprot.writeString(self.foreign_tbl_name)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
@@ -5891,8 +6525,10 @@ class Schema:
 
   def __hash__(self):
     value = 17
-    value = (value * 31) ^ hash(self.fieldSchemas)
-    value = (value * 31) ^ hash(self.properties)
+    value = (value * 31) ^ hash(self.parent_db_name)
+    value = (value * 31) ^ hash(self.parent_tbl_name)
+    value = (value * 31) ^ hash(self.foreign_db_name)
+    value = (value * 31) ^ hash(self.foreign_tbl_name)
     return value
 
   def __repr__(self):
@@ -5906,19 +6542,19 @@ class Schema:
   def __ne__(self, other):
     return not (self == other)
 
-class EnvironmentContext:
+class ForeignKeysResponse:
   """
   Attributes:
-   - properties
+   - foreignKeys
   """
 
   thrift_spec = (
     None, # 0
-    (1, TType.MAP, 'properties', (TType.STRING,None,TType.STRING,None), None, ), # 1
+    (1, TType.LIST, 'foreignKeys', (TType.STRUCT,(SQLForeignKey, SQLForeignKey.thrift_spec)), None, ), # 1
   )
 
-  def __init__(self, properties=None,):
-    self.properties = properties
+  def __init__(self, foreignKeys=None,):
+    self.foreignKeys = foreignKeys
 
   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:
@@ -5930,14 +6566,14 @@ class EnvironmentContext:
       if ftype == TType.STOP:
         break
       if fid == 1:
-        if ftype == TType.MAP:
-          self.properties = {}
-          (_ktype277, _vtype278, _size276 ) = iprot.readMapBegin()
-          for _i280 in xrange(_size276):
-            _key281 = iprot.readString()
-            _val282 = iprot.readString()
-            self.properties[_key281] = _val282
-          iprot.readMapEnd()
+        if ftype == TType.LIST:
+          self.foreignKeys = []
+          (_etype295, _size292) = iprot.readListBegin()
+          for _i296 in xrange(_size292):
+            _elem297 = SQLForeignKey()
+            _elem297.read(iprot)
+            self.foreignKeys.append(_elem297)
+          iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
@@ -5949,25 +6585,26 @@ class EnvironmentContext:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('EnvironmentContext')
-    if self.properties is not None:
-      oprot.writeFieldBegin('properties', TType.MAP, 1)
-      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.properties))
-      for kiter283,viter284 in self.properties.items():
-        oprot.writeString(kiter283)
-        oprot.writeString(viter284)
-      oprot.writeMapEnd()
+    oprot.writeStructBegin('ForeignKeysResponse')
+    if self.foreignKeys is not None:
+      oprot.writeFieldBegin('foreignKeys', TType.LIST, 1)
+      oprot.writeListBegin(TType.STRUCT, len(self.foreignKeys))
+      for iter298 in self.foreignKeys:
+        iter298.write(oprot)
+      oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
 
   def validate(self):
+    if self.foreignKeys is None:
+      raise TProtocol.TProtocolException(message='Required field foreignKeys is unset!')
     return
 
 
   def __hash__(self):
     value = 17
-    value = (value * 31) ^ hash(self.properties)
+    value = (value * 31) ^ hash(self.foreignKeys)
     return value
 
   def __repr__(self):
@@ -5981,7 +6618,7 @@ class EnvironmentContext:
   def __ne__(self, other):
     return not (self == other)
 
-class PrimaryKeysRequest:
+class UniqueConstraintsRequest:
   """
   Attributes:
    - db_name
@@ -6026,7 +6663,7 @@ class PrimaryKeysRequest:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('PrimaryKeysRequest')
+    oprot.writeStructBegin('UniqueConstraintsRequest')
     if self.db_name is not None:
       oprot.writeFieldBegin('db_name', TType.STRING, 1)
       oprot.writeString(self.db_name)
@@ -6063,19 +6700,19 @@ class PrimaryKeysRequest:
   def __ne__(self, other):
     return not (self == other)
 
-class PrimaryKeysResponse:
+class UniqueConstraintsResponse:
   """
   Attributes:
-   - primaryKeys
+   - uniqueConstraints
   """
 
   thrift_spec = (
     None, # 0
-    (1, TType.LIST, 'primaryKeys', (TType.STRUCT,(SQLPrimaryKey, SQLPrimaryKey.thrift_spec)), None, ), # 1
+    (1, TType.LIST, 'uniqueConstraints', (TType.STRUCT,(SQLUniqueConstraint, SQLUniqueConstraint.thrift_spec)), None, ), # 1
   )
 
-  def __init__(self, primaryKeys=None,):
-    self.primaryKeys = primaryKeys
+  def __init__(self, uniqueConstraints=None,):
+    self.uniqueConstraints = uniqueConstraints
 
   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:
@@ -6088,12 +6725,12 @@ class PrimaryKeysResponse:
         break
       if fid == 1:
         if ftype == TType.LIST:
-          self.primaryKeys = []
-          (_etype288, _size285) = iprot.readListBegin()
-          for _i289 in xrange(_size285):
-            _elem290 = SQLPrimaryKey()
-            _elem290.read(iprot)
-            self.primaryKeys.append(_elem290)
+          self.uniqueConstraints = []
+          (_etype302, _size299) = iprot.readListBegin()
+          for _i303 in xrange(_size299):
+            _elem304 = SQLUniqueConstraint()
+            _elem304.read(iprot)
+            self.uniqueConstraints.append(_elem304)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
@@ -6106,26 +6743,26 @@ class PrimaryKeysResponse:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('PrimaryKeysResponse')
-    if self.primaryKeys is not None:
-      oprot.writeFieldBegin('primaryKeys', TType.LIST, 1)
-      oprot.writeListBegin(TType.STRUCT, len(self.primaryKeys))
-      for iter291 in self.primaryKeys:
-        iter291.write(oprot)
+    oprot.writeStructBegin('UniqueConstraintsResponse')
+    if self.uniqueConstraints is not None:
+      oprot.writeFieldBegin('uniqueConstraints', TType.LIST, 1)
+      oprot.writeListBegin(TType.STRUCT, len(self.uniqueConstraints))
+      for iter305 in self.uniqueConstraints:
+        iter305.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
 
   def validate(self):
-    if self.primaryKeys is None:
-      raise TProtocol.TProtocolException(message='Required field primaryKeys is unset!')
+    if self.uniqueConstraints is None:
+      raise TProtocol.TProtocolException(message='Required field uniqueConstraints is unset!')
     return
 
 
   def __hash__(self):
     value = 17
-    value = (value * 31) ^ hash(self.primaryKeys)
+    value = (value * 31) ^ hash(self.uniqueConstraints)
     return value
 
   def __repr__(self):
@@ -6139,28 +6776,22 @@ class PrimaryKeysResponse:
   def __ne__(self, other):
     return not (self == other)
 
-class ForeignKeysRequest:
+class NotNullConstraintsRequest:
   """
   Attributes:
-   - parent_db_name
-   - parent_tbl_name
-   - foreign_db_name
-   - foreign_tbl_name
+   - db_name
+   - tbl_name
   """
 
   thrift_spec = (
     None, # 0
-    (1, TType.STRING, 'parent_db_name', None, None, ), # 1
-    (2, TType.STRING, 'parent_tbl_name', None, None, ), # 2
-    (3, TType.STRING, 'foreign_db_name', None, None, ), # 3
-    (4, TType.STRING, 'foreign_tbl_name', None, None, ), # 4
+    (1, TType.STRING, 'db_name', None, None, ), # 1
+    (2, TType.STRING, 'tbl_name', None, None, ), # 2
   )
 
-  def __init__(self, parent_db_name=None, parent_tbl_name=None, foreign_db_name=None, foreign_tbl_name=None,):
-    self.parent_db_name = parent_db_name
-    self.parent_tbl_name = parent_tbl_name
-    self.foreign_db_name = foreign_db_name
-    self.foreign_tbl_name = foreign_tbl_name
+  def __init__(self, db_name=None, tbl_name=None,):
+    self.db_name = db_name
+    self.tbl_name = tbl_name
 
   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:
@@ -6173,22 +6804,12 @@ class ForeignKeysRequest:
         break
       if fid == 1:
         if ftype == TType.STRING:
-          self.parent_db_name = iprot.readString()
+          self.db_name = iprot.readString()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.STRING:
-          self.parent_tbl_name = iprot.readString()
-        else:
-          iprot.skip(ftype)
-      elif fid == 3:
-        if ftype == TType.STRING:
-          self.foreign_db_name = iprot.readString()
-        else:
-          iprot.skip(ftype)
-      elif fid == 4:
-        if ftype == TType.STRING:
-          self.foreign_tbl_name = iprot.readString()
+          self.tbl_name = iprot.readString()
         else:
           iprot.skip(ftype)
       else:
@@ -6200,36 +6821,30 @@ class ForeignKeysRequest:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('ForeignKeysRequest')
-    if self.parent_db_name is not None:
-      oprot.writeFieldBegin('parent_db_name', TType.STRING, 1)
-      oprot.writeString(self.parent_db_name)
-      oprot.writeFieldEnd()
-    if self.parent_tbl_name is not None:
-      oprot.writeFieldBegin('parent_tbl_name', TType.STRING, 2)
-      oprot.writeString(self.parent_tbl_name)
-      oprot.writeFieldEnd()
-    if self.foreign_db_name is not None:
-      oprot.writeFieldBegin('foreign_db_name', TType.STRING, 3)
-      oprot.writeString(self.foreign_db_name)
+    oprot.writeStructBegin('NotNullConstraintsRequest')
+    if self.db_name is not None:
+      oprot.writeFieldBegin('db_name', TType.STRING, 1)
+      oprot.writeString(self.db_name)
       oprot.writeFieldEnd()
-    if self.foreign_tbl_name is not None:
-      oprot.writeFieldBegin('foreign_tbl_name', TType.STRING, 4)
-      oprot.writeString(self.foreign_tbl_name)
+    if self.tbl_name is not None:
+      oprot.writeFieldBegin('tbl_name', TType.STRING, 2)
+      oprot.writeString(self.tbl_name)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
 
   def validate(self):
+    if self.db_name is None:
+      raise TProtocol.TProtocolException(message='Required field db_name is unset!')
+    if self.tbl_name is None:
+      raise TProtocol.TProtocolException(message='Required field tbl_name is unset!')
     return
 
 
   def __hash__(self):
     value = 17
-    value = (value * 31) ^ hash(self.parent_db_name)
-    value = (value * 31) ^ hash(self.parent_tbl_name)
-    value = (value * 31) ^ hash(self.foreign_db_name)
-    value = (value * 31) ^ hash(self.foreign_tbl_name)
+    value = (value * 31) ^ hash(self.db_name)
+    value = (value * 31) ^ hash(self.tbl_name)
     return value
 
   def __repr__(self):
@@ -6243,19 +6858,19 @@ class ForeignKeysRequest:
   def __ne__(self, other):
     return not (self == other)
 
-class ForeignKeysResponse:
+class NotNullConstraintsResponse:
   """
   Attributes:
-   - foreignKeys
+   - notNullConstraints
   """
 
   thrift_spec = (
     None, # 0
-    (1, TType.LIST, 'foreignKeys', (TType.STRUCT,(SQLForeignKey, SQLForeignKey.thrift_spec)), None, ), # 1
+    (1, TType.LIST, 'notNullConstraints', (TType.STRUCT,(SQLNotNullConstraint, SQLNotNullConstraint.thrift_spec)), None, ), # 1
   )
 
-  def __init__(self, foreignKeys=None,):
-    self.foreignKeys = foreignKeys
+  def __init__(self, notNullConstraints=None,):
+    self.notNullConstraints = notNullConstraints
 
   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:
@@ -6268,12 +6883,12 @@ class ForeignKeysResponse:
         break
       if fid == 1:
         if ftype == TType.LIST:
-          self.foreignKeys = []
-          (_etype295, _size292) = iprot.readListBegin()
-          for _i296 in xrange(_size292):
-            _elem297 = SQLForeignKey()
-            _elem297.read(iprot)
-            self.foreignKeys.append(_elem297)
+          self.notNullConstraints = []
+          (_etype309, _size306) = iprot.readListBegin()
+          for _i310 in xrange(_size306):
+            _elem311 = SQLNotNullConstraint()
+            _elem311.read(iprot)
+            self.notNullConstraints.append(_elem311)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
@@ -6286,26 +6901,26 @@ class ForeignKeysResponse:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('ForeignKeysResponse')
-    if self.foreignKeys is not None:
-      oprot.writeFieldBegin('foreignKeys', TType.LIST, 1)
-      oprot.writeListBegin(TType.STRUCT, len(self.foreignKeys))
-      for iter298 in self.foreignKeys:
-        iter298.write(oprot)
+    oprot.writeStructBegin('NotNullConstraintsResponse')
+    if self.notNullConstraints is not None:
+      oprot.writeFieldBegin('notNullConstraints', TType.LIST, 1)
+      oprot.writeListBegin(TType.STRUCT, len(self.notNullConstraints))
+      for iter312 in self.notNullConstraints:
+        iter312.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
 
   def validate(self):
-    if self.foreignKeys is None:
-      raise TProtocol.TProtocolException(message='Required field foreignKeys is unset!')
+    if self.notNullConstraints is None:
+      raise TProtocol.TProtocolException(message='Required field notNullConstraints is unset!')
     return
 
 
   def __hash__(self):
     value = 17
-    value = (value * 31) ^ hash(self.foreignKeys)
+    value = (value * 31) ^ hash(self.notNullConstraints)
     return value
 
   def __repr__(self):
@@ -6442,11 +7057,11 @@ class AddPrimaryKeyRequest:
       if fid == 1:
         if ftype == TType.LIST:
           self.primaryKeyCols = []
-          (_etype302, _size299) = iprot.readListBegin()
-          for _i303 in xrange(_size299):
-            _elem304 = SQLPrimaryKey()
-            _elem304.read(iprot)
-            self.primaryKeyCols.append(_elem304)
+          (_etype316, _size313) = iprot.readListBegin()
+          for _i317 in xrange(_size313):
+            _elem318 = SQLPrimaryKey()
+            _elem318.read(iprot)
+            self.primaryKeyCols.append(_elem318)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
@@ -6463,8 +7078,8 @@ class AddPrimaryKeyRequest:
     if self.primaryKeyCols is not None:
       oprot.writeFieldBegin('primaryKeyCols', TType.LIST, 1)
       oprot.writeListBegin(TType.STRUCT, len(self.primaryKeyCols))
-      for iter305 in self.primaryKeyCols:
-        iter305.write(oprot)
+      for iter319 in self.primaryKeyCols:
+        iter319.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
@@ -6518,11 +7133,11 @@ class AddForeignKeyRequest:
       if fid == 1:
         if ftype == TType.LIST:
           self.foreignKeyCols = []
-          (_etype309, _size306) = iprot.readListBegin()
-          for _i310 in xrange(_size306):
-            _elem311 = SQLForeignKey()
-            _elem311.read(iprot)
-            self.foreignKeyCols.append(_elem311)
+          (_etype323, _size320) = iprot.readListBegin()
+          for _i324 in xrange(_size320):
+            _elem325 = SQLForeignKey()
+            _elem325.read(iprot)
+            self.foreignKeyCols.append(_elem325)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
@@ -6539,8 +7154,8 @@ class AddForeignKeyRequest:
     if self.foreignKeyCols is not None:
       oprot.writeFieldBegin('foreignKeyCols', TType.LIST, 1)
       oprot.writeListBegin(TType.STRUCT, len(self.foreignKeyCols))
-      for iter312 in self.foreignKeyCols:
-        iter312.write(oprot)
+      for iter326 in self.foreignKeyCols:
+        iter326.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
@@ -6568,6 +7183,158 @@ class AddForeignKeyRequest:
   def __ne__(self, other):
     return not (self == other)
 
+class AddUniqueConstraintRequest:
+  """
+  Attributes:
+   - uniqueConstraintCols
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.LIST, 'uniqueConstraintCols', (TType.STRUCT,(SQLUniqueConstraint, SQLUniqueConstraint.thrift_spec)), None, ), # 1
+  )
+
+  def __init__(self, uniqueConstraintCols=None,):
+    self.uniqueConstraintCols = uniqueConstraintCols
+
+  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:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.LIST:
+          self.uniqueConstraintCols = []
+          (_etype330, _size327) = iprot.readListBegin()
+          for _i331 in xrange(_size327):
+            _elem332 = SQLUniqueConstraint()
+            _elem332.read(iprot)
+            self.uniqueConstraintCols.append(_elem332)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('AddUniqueConstraintRequest')
+    if self.uniqueConstraintCols is not None:
+      oprot.writeFieldBegin('uniqueConstraintCols', TType.LIST, 1)
+      oprot.writeListBegin(TType.STRUCT, len(self.uniqueConstraintCols))
+      for iter333 in self.uniqueConstraintCols:
+        iter333.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    if self.uniqueConstraintCols is None:
+      raise TProtocol.TProtocolException(message='Required field uniqueConstraintCols is unset!')
+    return
+
+
+  def __hash__(self):
+    value = 17
+    value = (value * 31) ^ hash(self.uniqueConstraintCols)
+    return value
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class AddNotNullConstraintRequest:
+  """
+  Attributes:
+   - notNullConstraintCols
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.LIST, 'notNullConstraintCols', (TType.STRUCT,(SQLNotNullConstraint, SQLNotNullConstraint.thrift_spec)), None, ), # 1
+  )
+
+  def __init__(self, notNullConstraintCols=None,):
+    self.notNullConstraintCols = notNullConstraintCols
+
+  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:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.LIST:
+          self.notNullConstraintCols = []
+          (_etype337, _size334) = iprot.readListBegin()
+          for _i338 in xrange(_size334):
+            _elem339 = SQLNotNullConstraint()
+            _elem339.read(iprot)
+            self.notNullConstraintCols.append(_elem339)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('AddNotNullConstraintRequest')
+    if self.notNullConstraintCols is not None:
+      oprot.writeFieldBegin('notNullConstraintCols', TType.LIST, 1)
+      oprot.writeListBegin(TType.STRUCT, len(self.notNullConstraintCols))
+      for iter340 in self.notNullConstraintCols:
+        iter340.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    if self.notNullConstraintCols is None:
+      raise TProtocol.TProtocolException(message='Required field notNullConstraintCols is unset!')
+    return
+
+
+  def __hash__(self):
+    value = 17
+    value = (value * 31) ^ hash(self.notNullConstraintCols)
+    return value
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
 class PartitionsByExprResult:
   """
   Attributes:
@@ -6597,11 +7364,11 @@ class PartitionsByExprResult:
       if fid == 1:
         if ftype == TType.LIST:
           self.partitions = []
-          (_etype316, _size313) = iprot.readListBegin()
-          for _i317 in xrange(_size313):
-            _elem318 = Partition()
-            _elem318.read(iprot)
-            self.partitions.append(_elem318)
+          (_etype344, _size341) = iprot.readListBegin()
+          for _i345 in xrange(_size341):
+            _elem346 = Partition()
+            _elem346.read(iprot)
+            self.partitions.append(_elem346)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
@@ -6623,8 +7390,8 @@ class PartitionsByExprResult:
     if self.partitions is not None:
       oprot.writeFieldBegin('partitions', TType.LIST, 1)
       oprot.writeListBegin(TType.STRUCT, len(self.partitions))
-      for iter319 in self.partitions:
-        iter319.write(oprot)
+      for iter347 in self.partitions:
+        iter347.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.hasUnknownPartitions is not None:
@@ -6808,11 +7575,11 @@ class TableStatsResult:
       if fid == 1:
         if ftype == TType.LIST:
           self.tableStats = []
-          (_etype323, _size320) = iprot.readListBegin()
-          for _i324 in xrange(_size320):
-            _elem325 = ColumnStatisticsObj()
-            _elem325.read(iprot)
-            self.tableStats.append(_elem325)
+          (_etype351, _size348) = iprot.readListBegin()
+          for _i352 in xrange(_size348):
+            _elem353 = ColumnStatisticsObj()
+            _elem353.read(iprot)
+            self.tableStats.append(_elem353)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
@@ -6829,8 +7596,8 @@ class TableStatsResult:
     if self.tableStats is not None:
       oprot.writeFieldBegin('tableStats', TType.LIST, 1)
       oprot.writeListBegin(TType.STRUCT, len(self.tableStats))
-      for iter326 in self.tableStats:
-        iter326.write(oprot)
+      for iter354 in self.tableStats:
+        iter354.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
@@ -6884,17 +7651,17 @@ class PartitionsStatsResult:
       if fid == 1:
         if ftype == TType.MAP:
           self.partStats = {}
-          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
-          for _i331 in xrange(_size327):
-            _key332 = iprot.readString()
-            _val333 = []
-            (_etype337, _size334) = iprot.readListBegin()
-            for _i338 in xrange(_size334):
-              _elem339 = ColumnStatisticsObj()
-              _elem339.read(iprot)
-              _val333.append(_elem339)
+          (_ktype356, _vtype357, _size355 ) = iprot.readMapBegin()
+          for _i359 in xrange(_size355):
+            _key360 = iprot.readString()
+            _val361 = []
+            (_etype365, _size362) = iprot.readListBegin()
+            for _i366 in xrange(_size362):
+              _elem367 = ColumnStatisticsObj()
+              _elem367.read(iprot)
+              _val361.append(_elem367)
             iprot.readListEnd()
-            self.partStats[_key332] = _val333
+            self.partStats[_key360] = _val361
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
@@ -6911,11 +7678,11 @@ class PartitionsStatsResult:
     if self.partStats is not None:
       oprot.writeFieldBegin('partStats', TType.MAP, 1)
       oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.partStats))
-      for kiter340,viter341 in self.partStats.items():
-        oprot.writeString(kiter340)
-        oprot.writeListBegin(TType.STRUCT, len(viter341))
-        for iter342 in viter341:
-          iter342.write(oprot)
+      for kiter368,viter369 in self.partStats.items():
+        oprot.writeString(kiter368)
+        oprot.writeListBegin(TType.STRUCT, len(viter369))
+        for iter370 in viter369:
+          iter370.write(oprot)
         oprot.writeListEnd()
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
@@ -6986,10 +7753,10 @@ class TableStatsRequest:
       elif fid == 3:
         if ftype == TType.LIST:
           self.colNames = []
-          (_etype346, _size343) = iprot.readListBegin()
-          for _i347 in xrange(_size343):
-            _elem348 = iprot.readString()
-            self.colNames.append(_elem348)
+          (_etype374, _size371) = iprot.readListBegin()
+          for _i375 in xrange(_size371):
+            _elem376 = iprot.readString()
+            self.colNames.append(_elem376)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
@@ -7014,8 +7781,8 @@ class TableStatsRequest:
     if self.colNames is not None:
       oprot.writeFieldBegin('colNames', TType.LIST, 3)
       oprot.writeListBegin(TType.STRING, len(self.colNames))
-      for iter349 in self.colNames:
-        oprot.writeString(iter349)
+      for iter377 in self.colNames:
+        oprot.writeString(iter377)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
@@ -7094,20 +7861,20 @@ class PartitionsStatsRequest:
       elif fid == 3:
         if ftype == TType.LIST:
           self.colNames = []
-          (_etype353, _size350) = iprot.readListBegin()
-          for _i354 in xrange(_size350):
-            _elem355 = iprot.readString()
-            self.colNames.append(_elem355)
+          (_etype381, _size378) = iprot.readListBegin()
+          for _i382 in xrange(_size378):
+            _elem383 = iprot.readString()
+            self.colNames.append(_elem383)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 4:
         if ftype == TType.LIST:
           self.partNames = []
-          (_etype359, _size356) = iprot.readListBegin()
-          for _i360 in xrange(_size356):
-            _elem361 = iprot.readString()
-            self.partNames.append(_elem361)
+          (_etype387, _size384) = iprot.readListBegin()
+          for _i388 in xrange(_size384):
+            _elem389 = iprot.readString()
+            self.partNames.append(_elem389)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
@@ -7132,15 +7899,15 @@ class PartitionsStatsRequest:
     if self.colNames is not None:
       oprot.writeFieldBegin('colNames', TType.LIST, 3)
       oprot.writeListBegin(TType.STRING, len(self.colNames))
-      for iter362 in self.colNames:
-        oprot.writeString(iter362)
+      for iter390 in self.colNames:
+        oprot.writeString(iter390)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.partNames is not None:
       oprot.writeFieldBegin('partNames', TType.LIST, 4)
       oprot.writeListBegin(TType.STRING, len(self.partNames))
-      for iter363 in self.partNames:
-        oprot.writeString(iter363)
+      for iter391 in self.partNames:
+        oprot.writeString(iter391)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
@@ -7203,11 +7970,11 @@ class AddPartitionsResult:
       if fid == 1:
         if ftype == TType.LIST:
           self.partitions = []
-          (_etype367, _size364) = iprot.readListBegin()
-          for _i368 in xrange(_size364):
-            _elem369 = Partition()
-            _elem369.read(iprot)
-            self.partitions.append(_elem369)
+          (_etype395, _size392) = iprot.readListBegin()
+          for _i396 in xrange(_size392):
+            _elem397 = Partition()
+            _elem397.read(iprot)
+            self.partitions.append(_elem397)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
@@ -7224,8 +7991,8 @@ class AddPartitionsResu

<TRUNCATED>

Mime
View raw message