DRILL-6385: Support JPPD feature

4 files changed, 796 insertions, 8 deletions

diff --git a/contrib/native/client/src/protobuf/BitData.pb.cc b/contrib/native/client/src/protobuf/BitData.pb.cc
index 6f6e9db2d..b32509cab 100644
--- a/contrib/native/client/src/protobuf/BitData.pb.cc
+++ b/contrib/native/client/src/protobuf/BitData.pb.cc
@@ -31,6 +31,9 @@ const ::google::protobuf::internal::GeneratedMessageReflection*
 const ::google::protobuf::Descriptor* FragmentRecordBatch_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   FragmentRecordBatch_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RuntimeFilterBDef_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RuntimeFilterBDef_reflection_ = NULL;
 const ::google::protobuf::EnumDescriptor* RpcType_descriptor_ = NULL;
 
 }  // namespace
@@ -95,6 +98,26 @@ void protobuf_AssignDesc_BitData_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(FragmentRecordBatch));
+  RuntimeFilterBDef_descriptor_ = file->message_type(3);
+  static const int RuntimeFilterBDef_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RuntimeFilterBDef, query_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RuntimeFilterBDef, major_fragment_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RuntimeFilterBDef, minor_fragment_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RuntimeFilterBDef, to_foreman_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RuntimeFilterBDef, bloom_filter_size_in_bytes_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RuntimeFilterBDef, probe_fields_),
+  };
+  RuntimeFilterBDef_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RuntimeFilterBDef_descriptor_,
+      RuntimeFilterBDef::default_instance_,
+      RuntimeFilterBDef_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RuntimeFilterBDef, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RuntimeFilterBDef, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RuntimeFilterBDef));
   RpcType_descriptor_ = file->enum_type(0);
 }
 
@@ -114,6 +137,8 @@ void protobuf_RegisterTypes(const ::std::string&) {
     BitServerHandshake_descriptor_, &BitServerHandshake::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     FragmentRecordBatch_descriptor_, &FragmentRecordBatch::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RuntimeFilterBDef_descriptor_, &RuntimeFilterBDef::default_instance());
 }
 
 }  // namespace
@@ -125,6 +150,8 @@ void protobuf_ShutdownFile_BitData_2eproto() {
   delete BitServerHandshake_reflection_;
   delete FragmentRecordBatch::default_instance_;
   delete FragmentRecordBatch_reflection_;
+  delete RuntimeFilterBDef::default_instance_;
+  delete RuntimeFilterBDef_reflection_;
 }
 
 void protobuf_AddDesc_BitData_2eproto() {
@@ -150,18 +177,26 @@ void protobuf_AddDesc_BitData_2eproto() {
     " \003(\005\022!\n\031sending_major_fragment_id\030\004 \001(\005\022"
     "!\n\031sending_minor_fragment_id\030\005 \001(\005\022(\n\003de"
     "f\030\006 \001(\0132\033.exec.shared.RecordBatchDef\022\023\n\013"
-    "isLastBatch\030\007 \001(\010*V\n\007RpcType\022\r\n\tHANDSHAK"
-    "E\020\000\022\007\n\003ACK\020\001\022\013\n\007GOODBYE\020\002\022\024\n\020REQ_RECORD_"
-    "BATCH\020\003\022\020\n\014SASL_MESSAGE\020\004B(\n\033org.apache."
-    "drill.exec.protoB\007BitDataH\001", 667);
+    "isLastBatch\030\007 \001(\010\"\277\001\n\021RuntimeFilterBDef\022"
+    "&\n\010query_id\030\001 \001(\0132\024.exec.shared.QueryId\022"
+    "\031\n\021major_fragment_id\030\002 \001(\005\022\031\n\021minor_frag"
+    "ment_id\030\003 \001(\005\022\022\n\nto_foreman\030\004 \001(\010\022\"\n\032blo"
+    "om_filter_size_in_bytes\030\005 \003(\005\022\024\n\014probe_f"
+    "ields\030\006 \003(\t*n\n\007RpcType\022\r\n\tHANDSHAKE\020\000\022\007\n"
+    "\003ACK\020\001\022\013\n\007GOODBYE\020\002\022\024\n\020REQ_RECORD_BATCH\020"
+    "\003\022\020\n\014SASL_MESSAGE\020\004\022\026\n\022REQ_RUNTIME_FILTE"
+    "R\020\005B(\n\033org.apache.drill.exec.protoB\007BitD"
+    "ataH\001", 885);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "BitData.proto", &protobuf_RegisterTypes);
   BitClientHandshake::default_instance_ = new BitClientHandshake();
   BitServerHandshake::default_instance_ = new BitServerHandshake();
   FragmentRecordBatch::default_instance_ = new FragmentRecordBatch();
+  RuntimeFilterBDef::default_instance_ = new RuntimeFilterBDef();
   BitClientHandshake::default_instance_->InitAsDefaultInstance();
   BitServerHandshake::default_instance_->InitAsDefaultInstance();
   FragmentRecordBatch::default_instance_->InitAsDefaultInstance();
+  RuntimeFilterBDef::default_instance_->InitAsDefaultInstance();
   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_BitData_2eproto);
 }
 
@@ -182,6 +217,7 @@ bool RpcType_IsValid(int value) {
     case 2:
     case 3:
     case 4:
+    case 5:
       return true;
     default:
       return false;
@@ -1163,6 +1199,433 @@ void FragmentRecordBatch::Swap(FragmentRecordBatch* other) {
 }
 
 
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RuntimeFilterBDef::kQueryIdFieldNumber;
+const int RuntimeFilterBDef::kMajorFragmentIdFieldNumber;
+const int RuntimeFilterBDef::kMinorFragmentIdFieldNumber;
+const int RuntimeFilterBDef::kToForemanFieldNumber;
+const int RuntimeFilterBDef::kBloomFilterSizeInBytesFieldNumber;
+const int RuntimeFilterBDef::kProbeFieldsFieldNumber;
+#endif  // !_MSC_VER
+
+RuntimeFilterBDef::RuntimeFilterBDef()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void RuntimeFilterBDef::InitAsDefaultInstance() {
+  query_id_ = const_cast< ::exec::shared::QueryId*>(&::exec::shared::QueryId::default_instance());
+}
+
+RuntimeFilterBDef::RuntimeFilterBDef(const RuntimeFilterBDef& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void RuntimeFilterBDef::SharedCtor() {
+  _cached_size_ = 0;
+  query_id_ = NULL;
+  major_fragment_id_ = 0;
+  minor_fragment_id_ = 0;
+  to_foreman_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RuntimeFilterBDef::~RuntimeFilterBDef() {
+  SharedDtor();
+}
+
+void RuntimeFilterBDef::SharedDtor() {
+  if (this != default_instance_) {
+    delete query_id_;
+  }
+}
+
+void RuntimeFilterBDef::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RuntimeFilterBDef::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RuntimeFilterBDef_descriptor_;
+}
+
+const RuntimeFilterBDef& RuntimeFilterBDef::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_BitData_2eproto();
+  return *default_instance_;
+}
+
+RuntimeFilterBDef* RuntimeFilterBDef::default_instance_ = NULL;
+
+RuntimeFilterBDef* RuntimeFilterBDef::New() const {
+  return new RuntimeFilterBDef;
+}
+
+void RuntimeFilterBDef::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_query_id()) {
+      if (query_id_ != NULL) query_id_->::exec::shared::QueryId::Clear();
+    }
+    major_fragment_id_ = 0;
+    minor_fragment_id_ = 0;
+    to_foreman_ = false;
+  }
+  bloom_filter_size_in_bytes_.Clear();
+  probe_fields_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RuntimeFilterBDef::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .exec.shared.QueryId query_id = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_query_id()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(16)) goto parse_major_fragment_id;
+        break;
+      }
+
+      // optional int32 major_fragment_id = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_major_fragment_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &major_fragment_id_)));
+          set_has_major_fragment_id();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(24)) goto parse_minor_fragment_id;
+        break;
+      }
+
+      // optional int32 minor_fragment_id = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_minor_fragment_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &minor_fragment_id_)));
+          set_has_minor_fragment_id();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(32)) goto parse_to_foreman;
+        break;
+      }
+
+      // optional bool to_foreman = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_to_foreman:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &to_foreman_)));
+          set_has_to_foreman();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(40)) goto parse_bloom_filter_size_in_bytes;
+        break;
+      }
+
+      // repeated int32 bloom_filter_size_in_bytes = 5;
+      case 5: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_bloom_filter_size_in_bytes:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 1, 40, input, this->mutable_bloom_filter_size_in_bytes())));
+        } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
+                   == ::google::protobuf::internal::WireFormatLite::
+                      WIRETYPE_LENGTH_DELIMITED) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, this->mutable_bloom_filter_size_in_bytes())));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(40)) goto parse_bloom_filter_size_in_bytes;
+        if (input->ExpectTag(50)) goto parse_probe_fields;
+        break;
+      }
+
+      // repeated string probe_fields = 6;
+      case 6: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_probe_fields:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->add_probe_fields()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->probe_fields(this->probe_fields_size() - 1).data(),
+            this->probe_fields(this->probe_fields_size() - 1).length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(50)) goto parse_probe_fields;
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void RuntimeFilterBDef::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional .exec.shared.QueryId query_id = 1;
+  if (has_query_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->query_id(), output);
+  }
+
+  // optional int32 major_fragment_id = 2;
+  if (has_major_fragment_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->major_fragment_id(), output);
+  }
+
+  // optional int32 minor_fragment_id = 3;
+  if (has_minor_fragment_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->minor_fragment_id(), output);
+  }
+
+  // optional bool to_foreman = 4;
+  if (has_to_foreman()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->to_foreman(), output);
+  }
+
+  // repeated int32 bloom_filter_size_in_bytes = 5;
+  for (int i = 0; i < this->bloom_filter_size_in_bytes_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(
+      5, this->bloom_filter_size_in_bytes(i), output);
+  }
+
+  // repeated string probe_fields = 6;
+  for (int i = 0; i < this->probe_fields_size(); i++) {
+  ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+    this->probe_fields(i).data(), this->probe_fields(i).length(),
+    ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      6, this->probe_fields(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* RuntimeFilterBDef::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional .exec.shared.QueryId query_id = 1;
+  if (has_query_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->query_id(), target);
+  }
+
+  // optional int32 major_fragment_id = 2;
+  if (has_major_fragment_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->major_fragment_id(), target);
+  }
+
+  // optional int32 minor_fragment_id = 3;
+  if (has_minor_fragment_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->minor_fragment_id(), target);
+  }
+
+  // optional bool to_foreman = 4;
+  if (has_to_foreman()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->to_foreman(), target);
+  }
+
+  // repeated int32 bloom_filter_size_in_bytes = 5;
+  for (int i = 0; i < this->bloom_filter_size_in_bytes_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteInt32ToArray(5, this->bloom_filter_size_in_bytes(i), target);
+  }
+
+  // repeated string probe_fields = 6;
+  for (int i = 0; i < this->probe_fields_size(); i++) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->probe_fields(i).data(), this->probe_fields(i).length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteStringToArray(6, this->probe_fields(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int RuntimeFilterBDef::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .exec.shared.QueryId query_id = 1;
+    if (has_query_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->query_id());
+    }
+
+    // optional int32 major_fragment_id = 2;
+    if (has_major_fragment_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->major_fragment_id());
+    }
+
+    // optional int32 minor_fragment_id = 3;
+    if (has_minor_fragment_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->minor_fragment_id());
+    }
+
+    // optional bool to_foreman = 4;
+    if (has_to_foreman()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  // repeated int32 bloom_filter_size_in_bytes = 5;
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->bloom_filter_size_in_bytes_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        Int32Size(this->bloom_filter_size_in_bytes(i));
+    }
+    total_size += 1 * this->bloom_filter_size_in_bytes_size() + data_size;
+  }
+
+  // repeated string probe_fields = 6;
+  total_size += 1 * this->probe_fields_size();
+  for (int i = 0; i < this->probe_fields_size(); i++) {
+    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
+      this->probe_fields(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RuntimeFilterBDef::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RuntimeFilterBDef* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RuntimeFilterBDef*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RuntimeFilterBDef::MergeFrom(const RuntimeFilterBDef& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  bloom_filter_size_in_bytes_.MergeFrom(from.bloom_filter_size_in_bytes_);
+  probe_fields_.MergeFrom(from.probe_fields_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_query_id()) {
+      mutable_query_id()->::exec::shared::QueryId::MergeFrom(from.query_id());
+    }
+    if (from.has_major_fragment_id()) {
+      set_major_fragment_id(from.major_fragment_id());
+    }
+    if (from.has_minor_fragment_id()) {
+      set_minor_fragment_id(from.minor_fragment_id());
+    }
+    if (from.has_to_foreman()) {
+      set_to_foreman(from.to_foreman());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RuntimeFilterBDef::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RuntimeFilterBDef::CopyFrom(const RuntimeFilterBDef& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RuntimeFilterBDef::IsInitialized() const {
+
+  return true;
+}
+
+void RuntimeFilterBDef::Swap(RuntimeFilterBDef* other) {
+  if (other != this) {
+    std::swap(query_id_, other->query_id_);
+    std::swap(major_fragment_id_, other->major_fragment_id_);
+    std::swap(minor_fragment_id_, other->minor_fragment_id_);
+    std::swap(to_foreman_, other->to_foreman_);
+    bloom_filter_size_in_bytes_.Swap(&other->bloom_filter_size_in_bytes_);
+    probe_fields_.Swap(&other->probe_fields_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RuntimeFilterBDef::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RuntimeFilterBDef_descriptor_;
+  metadata.reflection = RuntimeFilterBDef_reflection_;
+  return metadata;
+}
+
+
 // @@protoc_insertion_point(namespace_scope)
 
 }  // namespace data
diff --git a/contrib/native/client/src/protobuf/BitData.pb.h b/contrib/native/client/src/protobuf/BitData.pb.h
index fa490c961..8a0b60cbb 100644
--- a/contrib/native/client/src/protobuf/BitData.pb.h
+++ b/contrib/native/client/src/protobuf/BitData.pb.h
@@ -42,17 +42,19 @@ void protobuf_ShutdownFile_BitData_2eproto();
 class BitClientHandshake;
 class BitServerHandshake;
 class FragmentRecordBatch;
+class RuntimeFilterBDef;
 
 enum RpcType {
   HANDSHAKE = 0,
   ACK = 1,
   GOODBYE = 2,
   REQ_RECORD_BATCH = 3,
-  SASL_MESSAGE = 4
+  SASL_MESSAGE = 4,
+  REQ_RUNTIME_FILTER = 5
 };
 bool RpcType_IsValid(int value);
 const RpcType RpcType_MIN = HANDSHAKE;
-const RpcType RpcType_MAX = SASL_MESSAGE;
+const RpcType RpcType_MAX = REQ_RUNTIME_FILTER;
 const int RpcType_ARRAYSIZE = RpcType_MAX + 1;
 
 const ::google::protobuf::EnumDescriptor* RpcType_descriptor();
@@ -405,6 +407,150 @@ class FragmentRecordBatch : public ::google::protobuf::Message {
   void InitAsDefaultInstance();
   static FragmentRecordBatch* default_instance_;
 };
+// -------------------------------------------------------------------
+
+class RuntimeFilterBDef : public ::google::protobuf::Message {
+ public:
+  RuntimeFilterBDef();
+  virtual ~RuntimeFilterBDef();
+
+  RuntimeFilterBDef(const RuntimeFilterBDef& from);
+
+  inline RuntimeFilterBDef& operator=(const RuntimeFilterBDef& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RuntimeFilterBDef& default_instance();
+
+  void Swap(RuntimeFilterBDef* other);
+
+  // implements Message ----------------------------------------------
+
+  RuntimeFilterBDef* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const RuntimeFilterBDef& from);
+  void MergeFrom(const RuntimeFilterBDef& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .exec.shared.QueryId query_id = 1;
+  inline bool has_query_id() const;
+  inline void clear_query_id();
+  static const int kQueryIdFieldNumber = 1;
+  inline const ::exec::shared::QueryId& query_id() const;
+  inline ::exec::shared::QueryId* mutable_query_id();
+  inline ::exec::shared::QueryId* release_query_id();
+  inline void set_allocated_query_id(::exec::shared::QueryId* query_id);
+
+  // optional int32 major_fragment_id = 2;
+  inline bool has_major_fragment_id() const;
+  inline void clear_major_fragment_id();
+  static const int kMajorFragmentIdFieldNumber = 2;
+  inline ::google::protobuf::int32 major_fragment_id() const;
+  inline void set_major_fragment_id(::google::protobuf::int32 value);
+
+  // optional int32 minor_fragment_id = 3;
+  inline bool has_minor_fragment_id() const;
+  inline void clear_minor_fragment_id();
+  static const int kMinorFragmentIdFieldNumber = 3;
+  inline ::google::protobuf::int32 minor_fragment_id() const;
+  inline void set_minor_fragment_id(::google::protobuf::int32 value);
+
+  // optional bool to_foreman = 4;
+  inline bool has_to_foreman() const;
+  inline void clear_to_foreman();
+  static const int kToForemanFieldNumber = 4;
+  inline bool to_foreman() const;
+  inline void set_to_foreman(bool value);
+
+  // repeated int32 bloom_filter_size_in_bytes = 5;
+  inline int bloom_filter_size_in_bytes_size() const;
+  inline void clear_bloom_filter_size_in_bytes();
+  static const int kBloomFilterSizeInBytesFieldNumber = 5;
+  inline ::google::protobuf::int32 bloom_filter_size_in_bytes(int index) const;
+  inline void set_bloom_filter_size_in_bytes(int index, ::google::protobuf::int32 value);
+  inline void add_bloom_filter_size_in_bytes(::google::protobuf::int32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
+      bloom_filter_size_in_bytes() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
+      mutable_bloom_filter_size_in_bytes();
+
+  // repeated string probe_fields = 6;
+  inline int probe_fields_size() const;
+  inline void clear_probe_fields();
+  static const int kProbeFieldsFieldNumber = 6;
+  inline const ::std::string& probe_fields(int index) const;
+  inline ::std::string* mutable_probe_fields(int index);
+  inline void set_probe_fields(int index, const ::std::string& value);
+  inline void set_probe_fields(int index, const char* value);
+  inline void set_probe_fields(int index, const char* value, size_t size);
+  inline ::std::string* add_probe_fields();
+  inline void add_probe_fields(const ::std::string& value);
+  inline void add_probe_fields(const char* value);
+  inline void add_probe_fields(const char* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& probe_fields() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_probe_fields();
+
+  // @@protoc_insertion_point(class_scope:exec.bit.data.RuntimeFilterBDef)
+ private:
+  inline void set_has_query_id();
+  inline void clear_has_query_id();
+  inline void set_has_major_fragment_id();
+  inline void clear_has_major_fragment_id();
+  inline void set_has_minor_fragment_id();
+  inline void clear_has_minor_fragment_id();
+  inline void set_has_to_foreman();
+  inline void clear_has_to_foreman();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::exec::shared::QueryId* query_id_;
+  ::google::protobuf::int32 major_fragment_id_;
+  ::google::protobuf::int32 minor_fragment_id_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > bloom_filter_size_in_bytes_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> probe_fields_;
+  bool to_foreman_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
+
+  friend void  protobuf_AddDesc_BitData_2eproto();
+  friend void protobuf_AssignDesc_BitData_2eproto();
+  friend void protobuf_ShutdownFile_BitData_2eproto();
+
+  void InitAsDefaultInstance();
+  static RuntimeFilterBDef* default_instance_;
+};
 // ===================================================================
 
 
@@ -720,6 +866,183 @@ inline void FragmentRecordBatch::set_islastbatch(bool value) {
   islastbatch_ = value;
 }
 
+// -------------------------------------------------------------------
+
+// RuntimeFilterBDef
+
+// optional .exec.shared.QueryId query_id = 1;
+inline bool RuntimeFilterBDef::has_query_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void RuntimeFilterBDef::set_has_query_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void RuntimeFilterBDef::clear_has_query_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void RuntimeFilterBDef::clear_query_id() {
+  if (query_id_ != NULL) query_id_->::exec::shared::QueryId::Clear();
+  clear_has_query_id();
+}
+inline const ::exec::shared::QueryId& RuntimeFilterBDef::query_id() const {
+  return query_id_ != NULL ? *query_id_ : *default_instance_->query_id_;
+}
+inline ::exec::shared::QueryId* RuntimeFilterBDef::mutable_query_id() {
+  set_has_query_id();
+  if (query_id_ == NULL) query_id_ = new ::exec::shared::QueryId;
+  return query_id_;
+}
+inline ::exec::shared::QueryId* RuntimeFilterBDef::release_query_id() {
+  clear_has_query_id();
+  ::exec::shared::QueryId* temp = query_id_;
+  query_id_ = NULL;
+  return temp;
+}
+inline void RuntimeFilterBDef::set_allocated_query_id(::exec::shared::QueryId* query_id) {
+  delete query_id_;
+  query_id_ = query_id;
+  if (query_id) {
+    set_has_query_id();
+  } else {
+    clear_has_query_id();
+  }
+}
+
+// optional int32 major_fragment_id = 2;
+inline bool RuntimeFilterBDef::has_major_fragment_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void RuntimeFilterBDef::set_has_major_fragment_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void RuntimeFilterBDef::clear_has_major_fragment_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void RuntimeFilterBDef::clear_major_fragment_id() {
+  major_fragment_id_ = 0;
+  clear_has_major_fragment_id();
+}
+inline ::google::protobuf::int32 RuntimeFilterBDef::major_fragment_id() const {
+  return major_fragment_id_;
+}
+inline void RuntimeFilterBDef::set_major_fragment_id(::google::protobuf::int32 value) {
+  set_has_major_fragment_id();
+  major_fragment_id_ = value;
+}
+
+// optional int32 minor_fragment_id = 3;
+inline bool RuntimeFilterBDef::has_minor_fragment_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void RuntimeFilterBDef::set_has_minor_fragment_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void RuntimeFilterBDef::clear_has_minor_fragment_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void RuntimeFilterBDef::clear_minor_fragment_id() {
+  minor_fragment_id_ = 0;
+  clear_has_minor_fragment_id();
+}
+inline ::google::protobuf::int32 RuntimeFilterBDef::minor_fragment_id() const {
+  return minor_fragment_id_;
+}
+inline void RuntimeFilterBDef::set_minor_fragment_id(::google::protobuf::int32 value) {
+  set_has_minor_fragment_id();
+  minor_fragment_id_ = value;
+}
+
+// optional bool to_foreman = 4;
+inline bool RuntimeFilterBDef::has_to_foreman() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void RuntimeFilterBDef::set_has_to_foreman() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void RuntimeFilterBDef::clear_has_to_foreman() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void RuntimeFilterBDef::clear_to_foreman() {
+  to_foreman_ = false;
+  clear_has_to_foreman();
+}
+inline bool RuntimeFilterBDef::to_foreman() const {
+  return to_foreman_;
+}
+inline void RuntimeFilterBDef::set_to_foreman(bool value) {
+  set_has_to_foreman();
+  to_foreman_ = value;
+}
+
+// repeated int32 bloom_filter_size_in_bytes = 5;
+inline int RuntimeFilterBDef::bloom_filter_size_in_bytes_size() const {
+  return bloom_filter_size_in_bytes_.size();
+}
+inline void RuntimeFilterBDef::clear_bloom_filter_size_in_bytes() {
+  bloom_filter_size_in_bytes_.Clear();
+}
+inline ::google::protobuf::int32 RuntimeFilterBDef::bloom_filter_size_in_bytes(int index) const {
+  return bloom_filter_size_in_bytes_.Get(index);
+}
+inline void RuntimeFilterBDef::set_bloom_filter_size_in_bytes(int index, ::google::protobuf::int32 value) {
+  bloom_filter_size_in_bytes_.Set(index, value);
+}
+inline void RuntimeFilterBDef::add_bloom_filter_size_in_bytes(::google::protobuf::int32 value) {
+  bloom_filter_size_in_bytes_.Add(value);
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
+RuntimeFilterBDef::bloom_filter_size_in_bytes() const {
+  return bloom_filter_size_in_bytes_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
+RuntimeFilterBDef::mutable_bloom_filter_size_in_bytes() {
+  return &bloom_filter_size_in_bytes_;
+}
+
+// repeated string probe_fields = 6;
+inline int RuntimeFilterBDef::probe_fields_size() const {
+  return probe_fields_.size();
+}
+inline void RuntimeFilterBDef::clear_probe_fields() {
+  probe_fields_.Clear();
+}
+inline const ::std::string& RuntimeFilterBDef::probe_fields(int index) const {
+  return probe_fields_.Get(index);
+}
+inline ::std::string* RuntimeFilterBDef::mutable_probe_fields(int index) {
+  return probe_fields_.Mutable(index);
+}
+inline void RuntimeFilterBDef::set_probe_fields(int index, const ::std::string& value) {
+  probe_fields_.Mutable(index)->assign(value);
+}
+inline void RuntimeFilterBDef::set_probe_fields(int index, const char* value) {
+  probe_fields_.Mutable(index)->assign(value);
+}
+inline void RuntimeFilterBDef::set_probe_fields(int index, const char* value, size_t size) {
+  probe_fields_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* RuntimeFilterBDef::add_probe_fields() {
+  return probe_fields_.Add();
+}
+inline void RuntimeFilterBDef::add_probe_fields(const ::std::string& value) {
+  probe_fields_.Add()->assign(value);
+}
+inline void RuntimeFilterBDef::add_probe_fields(const char* value) {
+  probe_fields_.Add()->assign(value);
+}
+inline void RuntimeFilterBDef::add_probe_fields(const char* value, size_t size) {
+  probe_fields_.Add()->assign(reinterpret_cast<const char*>(value), size);
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+RuntimeFilterBDef::probe_fields() const {
+  return probe_fields_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+RuntimeFilterBDef::mutable_probe_fields() {
+  return &probe_fields_;
+}
+
 
 // @@protoc_insertion_point(namespace_scope)
 
diff --git a/contrib/native/client/src/protobuf/UserBitShared.pb.cc b/contrib/native/client/src/protobuf/UserBitShared.pb.cc
index 8f98e06a0..574406d7c 100644
--- a/contrib/native/client/src/protobuf/UserBitShared.pb.cc
+++ b/contrib/native/client/src/protobuf/UserBitShared.pb.cc
@@ -779,6 +779,7 @@ void protobuf_AddDesc_UserBitShared_2eproto() {
     "TER\0202\022\026\n\022HTPPD_LOG_SUB_SCAN\0203\022\022\n\016IMAGE_S"
     "UB_SCAN\0204\022\025\n\021SEQUENCE_SUB_SCAN\0205\022\023\n\017PART"
     "ITION_LIMIT\0206\022\023\n\017PCAPNG_SUB_SCAN\0207*g\n\nSa"
+     "ITION_LIMIT\0206\022\022\n\016RUNTIME_FILTER\0207*g\n\nSas"
     "slStatus\022\020\n\014SASL_UNKNOWN\020\000\022\016\n\nSASL_START"
     "\020\001\022\024\n\020SASL_IN_PROGRESS\020\002\022\020\n\014SASL_SUCCESS"
     "\020\003\022\017\n\013SASL_FAILED\020\004B.\n\033org.apache.drill."
diff --git a/contrib/native/client/src/protobuf/UserBitShared.pb.h b/contrib/native/client/src/protobuf/UserBitShared.pb.h
index a07cbfa67..07ec0af0a 100644
--- a/contrib/native/client/src/protobuf/UserBitShared.pb.h
+++ b/contrib/native/client/src/protobuf/UserBitShared.pb.h
@@ -259,11 +259,12 @@ enum CoreOperatorType {
   IMAGE_SUB_SCAN = 52,
   SEQUENCE_SUB_SCAN = 53,
   PARTITION_LIMIT = 54,
-  PCAPNG_SUB_SCAN = 55
+  PCAPNG_SUB_SCAN = 55,
+   RUNTIME_FILTER = 56
 };
 bool CoreOperatorType_IsValid(int value);
 const CoreOperatorType CoreOperatorType_MIN = SINGLE_SENDER;
-const CoreOperatorType CoreOperatorType_MAX = PCAPNG_SUB_SCAN;
+const CoreOperatorType CoreOperatorType_MAX = RUNTIME_FILTER;
 const int CoreOperatorType_ARRAYSIZE = CoreOperatorType_MAX + 1;
 
 const ::google::protobuf::EnumDescriptor* CoreOperatorType_descriptor();