hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ekoif...@apache.org
Subject hive git commit: HIVE-15010 Make LockComponent aware if it's part of dynamic partition operation (Eugene Koifman, reviewed by Wei Zheng)
Date Wed, 19 Oct 2016 21:20:47 GMT
Repository: hive
Updated Branches:
  refs/heads/master f20ec2e93 -> 3252bed8f


HIVE-15010 Make LockComponent aware if it's part of dynamic partition operation (Eugene Koifman,
reviewed by Wei Zheng)


Project: http://git-wip-us.apache.org/repos/asf/hive/repo
Commit: http://git-wip-us.apache.org/repos/asf/hive/commit/3252bed8
Tree: http://git-wip-us.apache.org/repos/asf/hive/tree/3252bed8
Diff: http://git-wip-us.apache.org/repos/asf/hive/diff/3252bed8

Branch: refs/heads/master
Commit: 3252bed8faccc84cdf560e43674d31a9144abbe4
Parents: f20ec2e
Author: Eugene Koifman <ekoifman@hortonworks.com>
Authored: Wed Oct 19 14:20:29 2016 -0700
Committer: Eugene Koifman <ekoifman@hortonworks.com>
Committed: Wed Oct 19 14:20:29 2016 -0700

----------------------------------------------------------------------
 metastore/if/hive_metastore.thrift              |   3 +-
 .../gen/thrift/gen-cpp/hive_metastore_types.cpp |  22 ++++
 .../gen/thrift/gen-cpp/hive_metastore_types.h   |  12 +-
 .../hive/metastore/api/LockComponent.java       | 109 ++++++++++++++++++-
 .../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   |   4 +-
 7 files changed, 179 insertions(+), 9 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/hive/blob/3252bed8/metastore/if/hive_metastore.thrift
----------------------------------------------------------------------
diff --git a/metastore/if/hive_metastore.thrift b/metastore/if/hive_metastore.thrift
index 9f6ef91..42cb6f0 100755
--- a/metastore/if/hive_metastore.thrift
+++ b/metastore/if/hive_metastore.thrift
@@ -670,7 +670,8 @@ struct LockComponent {
     4: optional string tablename,
     5: optional string partitionname,
     6: optional DataOperationType operationType = DataOperationType.UNSET,
-    7: optional bool isAcid = false
+    7: optional bool isAcid = false,
+    8: optional bool isDynamicPartitionWrite = false
 }
 
 struct LockRequest {

http://git-wip-us.apache.org/repos/asf/hive/blob/3252bed8/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
index 89541fa..f3aaf7e 100644
--- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
+++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
@@ -12675,6 +12675,11 @@ void LockComponent::__set_isAcid(const bool val) {
 __isset.isAcid = true;
 }
 
+void LockComponent::__set_isDynamicPartitionWrite(const bool val) {
+  this->isDynamicPartitionWrite = val;
+__isset.isDynamicPartitionWrite = true;
+}
+
 uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
@@ -12761,6 +12766,14 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol*
iprot) {
           xfer += iprot->skip(ftype);
         }
         break;
+      case 8:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->isDynamicPartitionWrite);
+          this->__isset.isDynamicPartitionWrite = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
       default:
         xfer += iprot->skip(ftype);
         break;
@@ -12816,6 +12829,11 @@ uint32_t LockComponent::write(::apache::thrift::protocol::TProtocol*
oprot) cons
     xfer += oprot->writeBool(this->isAcid);
     xfer += oprot->writeFieldEnd();
   }
+  if (this->__isset.isDynamicPartitionWrite) {
+    xfer += oprot->writeFieldBegin("isDynamicPartitionWrite", ::apache::thrift::protocol::T_BOOL,
8);
+    xfer += oprot->writeBool(this->isDynamicPartitionWrite);
+    xfer += oprot->writeFieldEnd();
+  }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
@@ -12830,6 +12848,7 @@ void swap(LockComponent &a, LockComponent &b) {
   swap(a.partitionname, b.partitionname);
   swap(a.operationType, b.operationType);
   swap(a.isAcid, b.isAcid);
+  swap(a.isDynamicPartitionWrite, b.isDynamicPartitionWrite);
   swap(a.__isset, b.__isset);
 }
 
@@ -12841,6 +12860,7 @@ LockComponent::LockComponent(const LockComponent& other551) {
   partitionname = other551.partitionname;
   operationType = other551.operationType;
   isAcid = other551.isAcid;
+  isDynamicPartitionWrite = other551.isDynamicPartitionWrite;
   __isset = other551.__isset;
 }
 LockComponent& LockComponent::operator=(const LockComponent& other552) {
@@ -12851,6 +12871,7 @@ LockComponent& LockComponent::operator=(const LockComponent&
other552) {
   partitionname = other552.partitionname;
   operationType = other552.operationType;
   isAcid = other552.isAcid;
+  isDynamicPartitionWrite = other552.isDynamicPartitionWrite;
   __isset = other552.__isset;
   return *this;
 }
@@ -12864,6 +12885,7 @@ void LockComponent::printTo(std::ostream& out) const {
   out << ", " << "partitionname="; (__isset.partitionname ? (out << to_string(partitionname))
: (out << "<null>"));
   out << ", " << "operationType="; (__isset.operationType ? (out << to_string(operationType))
: (out << "<null>"));
   out << ", " << "isAcid="; (__isset.isAcid ? (out << to_string(isAcid))
: (out << "<null>"));
+  out << ", " << "isDynamicPartitionWrite="; (__isset.isDynamicPartitionWrite
? (out << to_string(isDynamicPartitionWrite)) : (out << "<null>"));
   out << ")";
 }
 

http://git-wip-us.apache.org/repos/asf/hive/blob/3252bed8/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
index 303c298..1252a2d 100644
--- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
+++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
@@ -5179,11 +5179,12 @@ inline std::ostream& operator<<(std::ostream& out, const
CommitTxnRequest& obj)
 }
 
 typedef struct _LockComponent__isset {
-  _LockComponent__isset() : tablename(false), partitionname(false), operationType(true),
isAcid(true) {}
+  _LockComponent__isset() : tablename(false), partitionname(false), operationType(true),
isAcid(true), isDynamicPartitionWrite(true) {}
   bool tablename :1;
   bool partitionname :1;
   bool operationType :1;
   bool isAcid :1;
+  bool isDynamicPartitionWrite :1;
 } _LockComponent__isset;
 
 class LockComponent {
@@ -5191,7 +5192,7 @@ class LockComponent {
 
   LockComponent(const LockComponent&);
   LockComponent& operator=(const LockComponent&);
-  LockComponent() : type((LockType::type)0), level((LockLevel::type)0), dbname(), tablename(),
partitionname(), operationType((DataOperationType::type)5), isAcid(false) {
+  LockComponent() : type((LockType::type)0), level((LockLevel::type)0), dbname(), tablename(),
partitionname(), operationType((DataOperationType::type)5), isAcid(false), isDynamicPartitionWrite(false)
{
     operationType = (DataOperationType::type)5;
 
   }
@@ -5204,6 +5205,7 @@ class LockComponent {
   std::string partitionname;
   DataOperationType::type operationType;
   bool isAcid;
+  bool isDynamicPartitionWrite;
 
   _LockComponent__isset __isset;
 
@@ -5221,6 +5223,8 @@ class LockComponent {
 
   void __set_isAcid(const bool val);
 
+  void __set_isDynamicPartitionWrite(const bool val);
+
   bool operator == (const LockComponent & rhs) const
   {
     if (!(type == rhs.type))
@@ -5245,6 +5249,10 @@ class LockComponent {
       return false;
     else if (__isset.isAcid && !(isAcid == rhs.isAcid))
       return false;
+    if (__isset.isDynamicPartitionWrite != rhs.__isset.isDynamicPartitionWrite)
+      return false;
+    else if (__isset.isDynamicPartitionWrite && !(isDynamicPartitionWrite == rhs.isDynamicPartitionWrite))
+      return false;
     return true;
   }
   bool operator != (const LockComponent &rhs) const {

http://git-wip-us.apache.org/repos/asf/hive/blob/3252bed8/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/LockComponent.java
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/LockComponent.java
b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/LockComponent.java
index 26d1b76..d349508 100644
--- a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/LockComponent.java
+++ b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/LockComponent.java
@@ -45,6 +45,7 @@ public class LockComponent implements org.apache.thrift.TBase<LockComponent,
Loc
   private static final org.apache.thrift.protocol.TField PARTITIONNAME_FIELD_DESC = new org.apache.thrift.protocol.TField("partitionname",
org.apache.thrift.protocol.TType.STRING, (short)5);
   private static final org.apache.thrift.protocol.TField OPERATION_TYPE_FIELD_DESC = new
org.apache.thrift.protocol.TField("operationType", org.apache.thrift.protocol.TType.I32, (short)6);
   private static final org.apache.thrift.protocol.TField IS_ACID_FIELD_DESC = new org.apache.thrift.protocol.TField("isAcid",
org.apache.thrift.protocol.TType.BOOL, (short)7);
+  private static final org.apache.thrift.protocol.TField IS_DYNAMIC_PARTITION_WRITE_FIELD_DESC
= new org.apache.thrift.protocol.TField("isDynamicPartitionWrite", org.apache.thrift.protocol.TType.BOOL,
(short)8);
 
   private static final Map<Class<? extends IScheme>, SchemeFactory> schemes =
new HashMap<Class<? extends IScheme>, SchemeFactory>();
   static {
@@ -59,6 +60,7 @@ public class LockComponent implements org.apache.thrift.TBase<LockComponent,
Loc
   private String partitionname; // optional
   private DataOperationType operationType; // optional
   private boolean isAcid; // optional
+  private boolean isDynamicPartitionWrite; // 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 {
@@ -80,7 +82,8 @@ public class LockComponent implements org.apache.thrift.TBase<LockComponent,
Loc
      * @see DataOperationType
      */
     OPERATION_TYPE((short)6, "operationType"),
-    IS_ACID((short)7, "isAcid");
+    IS_ACID((short)7, "isAcid"),
+    IS_DYNAMIC_PARTITION_WRITE((short)8, "isDynamicPartitionWrite");
 
     private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
 
@@ -109,6 +112,8 @@ public class LockComponent implements org.apache.thrift.TBase<LockComponent,
Loc
           return OPERATION_TYPE;
         case 7: // IS_ACID
           return IS_ACID;
+        case 8: // IS_DYNAMIC_PARTITION_WRITE
+          return IS_DYNAMIC_PARTITION_WRITE;
         default:
           return null;
       }
@@ -150,8 +155,9 @@ public class LockComponent implements org.apache.thrift.TBase<LockComponent,
Loc
 
   // isset id assignments
   private static final int __ISACID_ISSET_ID = 0;
+  private static final int __ISDYNAMICPARTITIONWRITE_ISSET_ID = 1;
   private byte __isset_bitfield = 0;
-  private static final _Fields optionals[] = {_Fields.TABLENAME,_Fields.PARTITIONNAME,_Fields.OPERATION_TYPE,_Fields.IS_ACID};
+  private static final _Fields optionals[] = {_Fields.TABLENAME,_Fields.PARTITIONNAME,_Fields.OPERATION_TYPE,_Fields.IS_ACID,_Fields.IS_DYNAMIC_PARTITION_WRITE};
   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);
@@ -169,6 +175,8 @@ public class LockComponent implements org.apache.thrift.TBase<LockComponent,
Loc
         new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM,
DataOperationType.class)));
     tmpMap.put(_Fields.IS_ACID, new org.apache.thrift.meta_data.FieldMetaData("isAcid", org.apache.thrift.TFieldRequirementType.OPTIONAL,

         new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+    tmpMap.put(_Fields.IS_DYNAMIC_PARTITION_WRITE, new org.apache.thrift.meta_data.FieldMetaData("isDynamicPartitionWrite",
org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
     metaDataMap = Collections.unmodifiableMap(tmpMap);
     org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(LockComponent.class, metaDataMap);
   }
@@ -178,6 +186,8 @@ public class LockComponent implements org.apache.thrift.TBase<LockComponent,
Loc
 
     this.isAcid = false;
 
+    this.isDynamicPartitionWrite = false;
+
   }
 
   public LockComponent(
@@ -215,6 +225,7 @@ public class LockComponent implements org.apache.thrift.TBase<LockComponent,
Loc
       this.operationType = other.operationType;
     }
     this.isAcid = other.isAcid;
+    this.isDynamicPartitionWrite = other.isDynamicPartitionWrite;
   }
 
   public LockComponent deepCopy() {
@@ -232,6 +243,8 @@ public class LockComponent implements org.apache.thrift.TBase<LockComponent,
Loc
 
     this.isAcid = false;
 
+    this.isDynamicPartitionWrite = false;
+
   }
 
   /**
@@ -418,6 +431,28 @@ public class LockComponent implements org.apache.thrift.TBase<LockComponent,
Loc
     __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __ISACID_ISSET_ID, value);
   }
 
+  public boolean isIsDynamicPartitionWrite() {
+    return this.isDynamicPartitionWrite;
+  }
+
+  public void setIsDynamicPartitionWrite(boolean isDynamicPartitionWrite) {
+    this.isDynamicPartitionWrite = isDynamicPartitionWrite;
+    setIsDynamicPartitionWriteIsSet(true);
+  }
+
+  public void unsetIsDynamicPartitionWrite() {
+    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __ISDYNAMICPARTITIONWRITE_ISSET_ID);
+  }
+
+  /** Returns true if field isDynamicPartitionWrite is set (has been assigned a value) and
false otherwise */
+  public boolean isSetIsDynamicPartitionWrite() {
+    return EncodingUtils.testBit(__isset_bitfield, __ISDYNAMICPARTITIONWRITE_ISSET_ID);
+  }
+
+  public void setIsDynamicPartitionWriteIsSet(boolean value) {
+    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __ISDYNAMICPARTITIONWRITE_ISSET_ID,
value);
+  }
+
   public void setFieldValue(_Fields field, Object value) {
     switch (field) {
     case TYPE:
@@ -476,6 +511,14 @@ public class LockComponent implements org.apache.thrift.TBase<LockComponent,
Loc
       }
       break;
 
+    case IS_DYNAMIC_PARTITION_WRITE:
+      if (value == null) {
+        unsetIsDynamicPartitionWrite();
+      } else {
+        setIsDynamicPartitionWrite((Boolean)value);
+      }
+      break;
+
     }
   }
 
@@ -502,6 +545,9 @@ public class LockComponent implements org.apache.thrift.TBase<LockComponent,
Loc
     case IS_ACID:
       return isIsAcid();
 
+    case IS_DYNAMIC_PARTITION_WRITE:
+      return isIsDynamicPartitionWrite();
+
     }
     throw new IllegalStateException();
   }
@@ -527,6 +573,8 @@ public class LockComponent implements org.apache.thrift.TBase<LockComponent,
Loc
       return isSetOperationType();
     case IS_ACID:
       return isSetIsAcid();
+    case IS_DYNAMIC_PARTITION_WRITE:
+      return isSetIsDynamicPartitionWrite();
     }
     throw new IllegalStateException();
   }
@@ -607,6 +655,15 @@ public class LockComponent implements org.apache.thrift.TBase<LockComponent,
Loc
         return false;
     }
 
+    boolean this_present_isDynamicPartitionWrite = true && this.isSetIsDynamicPartitionWrite();
+    boolean that_present_isDynamicPartitionWrite = true && that.isSetIsDynamicPartitionWrite();
+    if (this_present_isDynamicPartitionWrite || that_present_isDynamicPartitionWrite) {
+      if (!(this_present_isDynamicPartitionWrite && that_present_isDynamicPartitionWrite))
+        return false;
+      if (this.isDynamicPartitionWrite != that.isDynamicPartitionWrite)
+        return false;
+    }
+
     return true;
   }
 
@@ -649,6 +706,11 @@ public class LockComponent implements org.apache.thrift.TBase<LockComponent,
Loc
     if (present_isAcid)
       list.add(isAcid);
 
+    boolean present_isDynamicPartitionWrite = true && (isSetIsDynamicPartitionWrite());
+    list.add(present_isDynamicPartitionWrite);
+    if (present_isDynamicPartitionWrite)
+      list.add(isDynamicPartitionWrite);
+
     return list.hashCode();
   }
 
@@ -730,6 +792,16 @@ public class LockComponent implements org.apache.thrift.TBase<LockComponent,
Loc
         return lastComparison;
       }
     }
+    lastComparison = Boolean.valueOf(isSetIsDynamicPartitionWrite()).compareTo(other.isSetIsDynamicPartitionWrite());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetIsDynamicPartitionWrite()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.isDynamicPartitionWrite,
other.isDynamicPartitionWrite);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
     return 0;
   }
 
@@ -809,6 +881,12 @@ public class LockComponent implements org.apache.thrift.TBase<LockComponent,
Loc
       sb.append(this.isAcid);
       first = false;
     }
+    if (isSetIsDynamicPartitionWrite()) {
+      if (!first) sb.append(", ");
+      sb.append("isDynamicPartitionWrite:");
+      sb.append(this.isDynamicPartitionWrite);
+      first = false;
+    }
     sb.append(")");
     return sb.toString();
   }
@@ -922,6 +1000,14 @@ public class LockComponent implements org.apache.thrift.TBase<LockComponent,
Loc
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
             }
             break;
+          case 8: // IS_DYNAMIC_PARTITION_WRITE
+            if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+              struct.isDynamicPartitionWrite = iprot.readBool();
+              struct.setIsDynamicPartitionWriteIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
           default:
             org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
         }
@@ -976,6 +1062,11 @@ public class LockComponent implements org.apache.thrift.TBase<LockComponent,
Loc
         oprot.writeBool(struct.isAcid);
         oprot.writeFieldEnd();
       }
+      if (struct.isSetIsDynamicPartitionWrite()) {
+        oprot.writeFieldBegin(IS_DYNAMIC_PARTITION_WRITE_FIELD_DESC);
+        oprot.writeBool(struct.isDynamicPartitionWrite);
+        oprot.writeFieldEnd();
+      }
       oprot.writeFieldStop();
       oprot.writeStructEnd();
     }
@@ -1009,7 +1100,10 @@ public class LockComponent implements org.apache.thrift.TBase<LockComponent,
Loc
       if (struct.isSetIsAcid()) {
         optionals.set(3);
       }
-      oprot.writeBitSet(optionals, 4);
+      if (struct.isSetIsDynamicPartitionWrite()) {
+        optionals.set(4);
+      }
+      oprot.writeBitSet(optionals, 5);
       if (struct.isSetTablename()) {
         oprot.writeString(struct.tablename);
       }
@@ -1022,6 +1116,9 @@ public class LockComponent implements org.apache.thrift.TBase<LockComponent,
Loc
       if (struct.isSetIsAcid()) {
         oprot.writeBool(struct.isAcid);
       }
+      if (struct.isSetIsDynamicPartitionWrite()) {
+        oprot.writeBool(struct.isDynamicPartitionWrite);
+      }
     }
 
     @Override
@@ -1033,7 +1130,7 @@ public class LockComponent implements org.apache.thrift.TBase<LockComponent,
Loc
       struct.setLevelIsSet(true);
       struct.dbname = iprot.readString();
       struct.setDbnameIsSet(true);
-      BitSet incoming = iprot.readBitSet(4);
+      BitSet incoming = iprot.readBitSet(5);
       if (incoming.get(0)) {
         struct.tablename = iprot.readString();
         struct.setTablenameIsSet(true);
@@ -1050,6 +1147,10 @@ public class LockComponent implements org.apache.thrift.TBase<LockComponent,
Loc
         struct.isAcid = iprot.readBool();
         struct.setIsAcidIsSet(true);
       }
+      if (incoming.get(4)) {
+        struct.isDynamicPartitionWrite = iprot.readBool();
+        struct.setIsDynamicPartitionWriteIsSet(true);
+      }
     }
   }
 

http://git-wip-us.apache.org/repos/asf/hive/blob/3252bed8/metastore/src/gen/thrift/gen-php/metastore/Types.php
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-php/metastore/Types.php b/metastore/src/gen/thrift/gen-php/metastore/Types.php
index 18895cf..61171c2 100644
--- a/metastore/src/gen/thrift/gen-php/metastore/Types.php
+++ b/metastore/src/gen/thrift/gen-php/metastore/Types.php
@@ -12719,6 +12719,10 @@ class LockComponent {
    * @var bool
    */
   public $isAcid = false;
+  /**
+   * @var bool
+   */
+  public $isDynamicPartitionWrite = false;
 
   public function __construct($vals=null) {
     if (!isset(self::$_TSPEC)) {
@@ -12751,6 +12755,10 @@ class LockComponent {
           'var' => 'isAcid',
           'type' => TType::BOOL,
           ),
+        8 => array(
+          'var' => 'isDynamicPartitionWrite',
+          'type' => TType::BOOL,
+          ),
         );
     }
     if (is_array($vals)) {
@@ -12775,6 +12783,9 @@ class LockComponent {
       if (isset($vals['isAcid'])) {
         $this->isAcid = $vals['isAcid'];
       }
+      if (isset($vals['isDynamicPartitionWrite'])) {
+        $this->isDynamicPartitionWrite = $vals['isDynamicPartitionWrite'];
+      }
     }
   }
 
@@ -12846,6 +12857,13 @@ class LockComponent {
             $xfer += $input->skip($ftype);
           }
           break;
+        case 8:
+          if ($ftype == TType::BOOL) {
+            $xfer += $input->readBool($this->isDynamicPartitionWrite);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
         default:
           $xfer += $input->skip($ftype);
           break;
@@ -12894,6 +12912,11 @@ class LockComponent {
       $xfer += $output->writeBool($this->isAcid);
       $xfer += $output->writeFieldEnd();
     }
+    if ($this->isDynamicPartitionWrite !== null) {
+      $xfer += $output->writeFieldBegin('isDynamicPartitionWrite', TType::BOOL, 8);
+      $xfer += $output->writeBool($this->isDynamicPartitionWrite);
+      $xfer += $output->writeFieldEnd();
+    }
     $xfer += $output->writeFieldStop();
     $xfer += $output->writeStructEnd();
     return $xfer;

http://git-wip-us.apache.org/repos/asf/hive/blob/3252bed8/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 65a65dd..879fc99 100644
--- a/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py
+++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py
@@ -8792,6 +8792,7 @@ class LockComponent:
    - partitionname
    - operationType
    - isAcid
+   - isDynamicPartitionWrite
   """
 
   thrift_spec = (
@@ -8803,9 +8804,10 @@ class LockComponent:
     (5, TType.STRING, 'partitionname', None, None, ), # 5
     (6, TType.I32, 'operationType', None,     5, ), # 6
     (7, TType.BOOL, 'isAcid', None, False, ), # 7
+    (8, TType.BOOL, 'isDynamicPartitionWrite', None, False, ), # 8
   )
 
-  def __init__(self, type=None, level=None, dbname=None, tablename=None, partitionname=None,
operationType=thrift_spec[6][4], isAcid=thrift_spec[7][4],):
+  def __init__(self, type=None, level=None, dbname=None, tablename=None, partitionname=None,
operationType=thrift_spec[6][4], isAcid=thrift_spec[7][4], isDynamicPartitionWrite=thrift_spec[8][4],):
     self.type = type
     self.level = level
     self.dbname = dbname
@@ -8813,6 +8815,7 @@ class LockComponent:
     self.partitionname = partitionname
     self.operationType = operationType
     self.isAcid = isAcid
+    self.isDynamicPartitionWrite = isDynamicPartitionWrite
 
   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:
@@ -8858,6 +8861,11 @@ class LockComponent:
           self.isAcid = iprot.readBool()
         else:
           iprot.skip(ftype)
+      elif fid == 8:
+        if ftype == TType.BOOL:
+          self.isDynamicPartitionWrite = iprot.readBool()
+        else:
+          iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
@@ -8896,6 +8904,10 @@ class LockComponent:
       oprot.writeFieldBegin('isAcid', TType.BOOL, 7)
       oprot.writeBool(self.isAcid)
       oprot.writeFieldEnd()
+    if self.isDynamicPartitionWrite is not None:
+      oprot.writeFieldBegin('isDynamicPartitionWrite', TType.BOOL, 8)
+      oprot.writeBool(self.isDynamicPartitionWrite)
+      oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
 
@@ -8918,6 +8930,7 @@ class LockComponent:
     value = (value * 31) ^ hash(self.partitionname)
     value = (value * 31) ^ hash(self.operationType)
     value = (value * 31) ^ hash(self.isAcid)
+    value = (value * 31) ^ hash(self.isDynamicPartitionWrite)
     return value
 
   def __repr__(self):

http://git-wip-us.apache.org/repos/asf/hive/blob/3252bed8/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb b/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb
index 51adf50..cf64423 100644
--- a/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb
+++ b/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb
@@ -1967,6 +1967,7 @@ class LockComponent
   PARTITIONNAME = 5
   OPERATIONTYPE = 6
   ISACID = 7
+  ISDYNAMICPARTITIONWRITE = 8
 
   FIELDS = {
     TYPE => {:type => ::Thrift::Types::I32, :name => 'type', :enum_class => ::LockType},
@@ -1975,7 +1976,8 @@ class LockComponent
     TABLENAME => {:type => ::Thrift::Types::STRING, :name => 'tablename', :optional
=> true},
     PARTITIONNAME => {:type => ::Thrift::Types::STRING, :name => 'partitionname',
:optional => true},
     OPERATIONTYPE => {:type => ::Thrift::Types::I32, :name => 'operationType', :default
=>     5, :optional => true, :enum_class => ::DataOperationType},
-    ISACID => {:type => ::Thrift::Types::BOOL, :name => 'isAcid', :default =>
false, :optional => true}
+    ISACID => {:type => ::Thrift::Types::BOOL, :name => 'isAcid', :default =>
false, :optional => true},
+    ISDYNAMICPARTITIONWRITE => {:type => ::Thrift::Types::BOOL, :name => 'isDynamicPartitionWrite',
:default => false, :optional => true}
   }
 
   def struct_fields; FIELDS; end


Mime
View raw message